2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
14 // This should generally only be used to print panic messages
15 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
16 var bytes_written = 0;
17 for (var i = 0; i < iovec_array_len; i++) {
18 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
19 console.log("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
20 bytes_written += ptr_len_view[i*2+1]!;
22 const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
23 written_view[0] = bytes_written;
26 "fd_close": (_fd: number) => {
27 // This is not generally called, but may be referenced in debug builds
28 console.log("wasi_snapshot_preview1:fd_close");
29 return 58; // Not Supported
31 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
32 // This is not generally called, but may be referenced in debug builds
33 console.log("wasi_snapshot_preview1:fd_seek");
34 return 58; // Not Supported
36 "random_get": (buf_ptr: number, buf_len: number) => {
37 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
41 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
42 // This is called before fd_write to format + print panic messages
43 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
44 out_count_view[0] = 0;
45 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
49 "environ_get": (_environ_ptr: number, _environ_buf_ptr: number) => {
50 // This is called before fd_write to format + print panic messages,
51 // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
52 console.log("wasi_snapshot_preview1:environ_get");
53 return 58; // Note supported - we said there were 0 environment entries!
56 console.log("wasi_snapshot_preview1:proc_exit");
61 let isWasmInitialized: boolean = false;
63 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
64 if (typeof crypto === "undefined") {
65 var crypto_import = (await import('crypto')).webcrypto;
66 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
68 getRandomValues = crypto.getRandomValues.bind(crypto);
71 wasm = wasmInstance.exports;
72 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
73 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
76 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
77 throw new Error("Compiled LDK library and LDK class files do not match");
78 // Fetching the LDK versions from C also checks that the header and binaries match
79 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
80 const ldk_ver: number = wasm.TS_get_ldk_version();
81 if (c_bindings_ver == 0)
82 throw new Error("LDK version did not match the header we built against");
84 throw new Error("LDK C bindings version did not match the header we built against");
85 const c_bindings_version: string = decodeString(c_bindings_ver)
86 const ldk_version: string = decodeString(ldk_ver);
87 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
89 isWasmInitialized = true;
92 const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu",
93 "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uububu", "ububuu"];
96 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
97 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
98 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
99 await finishInitializeWasm(wasmInstance);
103 export async function initializeWasmFetch(uri: string) {
104 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
105 const stream = fetch(uri);
106 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
107 await finishInitializeWasm(wasmInstance);
112 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
113 const arr = new Uint8Array(inputArray.length);
114 for (var i = 0; i < inputArray.length; i++) {
115 arr[i] = inputArray[i]!.getVal();
121 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
122 const arr = new Uint8Array(inputArray.length);
123 for (var i = 0; i < inputArray.length; i++) {
124 arr[i] = inputArray[i]!.getVal();
132 export function encodeUint128 (inputVal: bigint): number {
133 if (inputVal >= 0x10000000000000000000000000000000n) throw "U128s cannot exceed 128 bits";
134 const cArrayPointer = wasm.TS_malloc(16 + 8);
135 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
136 arrayLengthView[0] = BigInt(16);
137 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, 16);
138 for (var i = 0; i < 16; i++) arrayMemoryView[i] = Number((inputVal >> BigInt(i)*8n) & 0xffn);
139 return cArrayPointer;
142 export function encodeUint8Array (inputArray: Uint8Array|null): number {
143 if (inputArray == null) return 0;
144 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
145 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = BigInt(inputArray.length);
147 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
152 export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
153 if (inputArray == null) return 0;
154 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
155 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
156 arrayLengthView[0] = BigInt(inputArray.length);
157 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
158 arrayMemoryView.set(inputArray);
159 return cArrayPointer;
162 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
163 if (inputArray == null) return 0;
164 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
165 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
166 arrayMemoryView[0] = BigInt(inputArray.length);
167 arrayMemoryView.set(inputArray, 1);
168 return cArrayPointer;
172 export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
173 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
178 export function getArrayLength(arrayPointer: number): number {
179 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
180 const len = arraySizeViewer[0]!;
181 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
182 return Number(len % (2n ** 32n));
185 export function decodeUint128 (arrayPointer: number, free = true): bigint {
186 const arraySize = getArrayLength(arrayPointer);
187 if (arraySize != 16) throw "Need 16 bytes for a uint128";
188 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
190 for (var i = 0; i < 16; i++) {
192 val |= BigInt(actualArrayViewer[i]!);
195 wasm.TS_free(arrayPointer);
200 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
201 const arraySize = getArrayLength(arrayPointer);
202 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
203 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
204 // will free the underlying memory when it becomes unreachable instead of copying here.
205 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
206 const actualArray = actualArrayViewer.slice(0, arraySize);
208 wasm.TS_free(arrayPointer);
212 const decodeUint32Array = (arrayPointer: number, free = true) => {
213 const arraySize = getArrayLength(arrayPointer);
214 const actualArrayViewer = new Uint32Array(
215 wasm.memory.buffer, // value
216 arrayPointer + 8, // offset (ignoring length bytes)
217 arraySize // uint32 count
219 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
220 // will free the underlying memory when it becomes unreachable instead of copying here.
221 const actualArray = actualArrayViewer.slice(0, arraySize);
223 wasm.TS_free(arrayPointer);
228 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
229 const arraySize = getArrayLength(arrayPointer);
230 const actualArrayViewer = new BigUint64Array(
231 wasm.memory.buffer, // value
232 arrayPointer + 8, // offset (ignoring length bytes)
233 arraySize // uint32 count
235 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
236 // will free the underlying memory when it becomes unreachable instead of copying here.
237 const actualArray = new Array(arraySize);
238 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
240 wasm.TS_free(arrayPointer);
245 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
248 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
249 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
250 return actualArrayViewer[idx]!;
254 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
255 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
256 return actualArrayViewer[idx]!;
260 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
261 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
262 return actualArrayViewer[idx]!;
267 export function encodeString(str: string): number {
268 const charArray = new TextEncoder().encode(str);
269 return encodeUint8Array(charArray);
273 export function decodeString(stringPointer: number, free = true): string {
274 const arraySize = getArrayLength(stringPointer);
275 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
276 const result = new TextDecoder("utf-8").decode(memoryView);
279 wasm.TS_free(stringPointer);
285 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
286 /* @internal */ export function debugPrintRemainingAllocs() { }
289 * An error when accessing the chain via [`Access`].
291 export enum AccessError {
293 * The requested chain is unknown.
295 LDKAccessError_UnknownChain,
297 * The requested transaction doesn't exist or hasn't confirmed.
299 LDKAccessError_UnknownTx,
304 * An enum which can either contain a or not
306 export enum COption_NoneZ {
308 * When we're in this state, this COption_NoneZ contains a
310 LDKCOption_NoneZ_Some,
312 * When we're in this state, this COption_NoneZ contains nothing
314 LDKCOption_NoneZ_None,
319 * An enum representing the status of a channel monitor update persistence.
321 export enum ChannelMonitorUpdateStatus {
323 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
326 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
327 be available on restart even if the application crashes.
329 LDKChannelMonitorUpdateStatus_Completed,
331 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
332 our state failed, but is expected to succeed at some point in the future).
334 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
335 submitting new commitment transactions to the counterparty. Once the update(s) which failed
336 have been successfully applied, a [`MonitorEvent::Completed`] can be used to restore the
337 channel to an operational state.
339 Note that a given [`ChannelManager`] will *never* re-generate a [`ChannelMonitorUpdate`].
340 If you return this error you must ensure that it is written to disk safely before writing
341 the latest [`ChannelManager`] state, or you should return [`PermanentFailure`] instead.
343 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
344 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
345 attempting to claim it on this channel) and those updates must still be persisted.
347 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
348 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
349 monitor update for the same channel.
351 For deployments where a copy of ChannelMonitors and other local state are backed up in a
352 remote location (with local copies persisted immediately), it is anticipated that all
353 updates will return [`InProgress`] until the remote copies could be updated.
355 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
356 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
357 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
359 LDKChannelMonitorUpdateStatus_InProgress,
361 * Used to indicate no further channel monitor updates will be allowed (likely a disk failure
362 or a remote copy of this [`ChannelMonitor`] is no longer reachable and thus not updatable).
364 When this is returned, [`ChannelManager`] will force-close the channel but *not* broadcast
365 our current commitment transaction. This avoids a dangerous case where a local disk failure
366 (e.g. the Linux-default remounting of the disk as read-only) causes [`PermanentFailure`]s
367 for all monitor updates. If we were to broadcast our latest commitment transaction and then
368 restart, we could end up reading a previous [`ChannelMonitor`] and [`ChannelManager`],
369 revoking our now-broadcasted state before seeing it confirm and losing all our funds.
371 Note that this is somewhat of a tradeoff - if the disk is really gone and we may have lost
372 the data permanently, we really should broadcast immediately. If the data can be recovered
373 with manual intervention, we'd rather close the channel, rejecting future updates to it,
374 and broadcast the latest state only if we have HTLCs to claim which are timing out (which
375 we do as long as blocks are connected).
377 In order to broadcast the latest local commitment transaction, you'll need to call
378 [`ChannelMonitor::get_latest_holder_commitment_txn`] and broadcast the resulting
379 transactions once you've safely ensured no further channel updates can be generated by your
382 Note that at least one final [`ChannelMonitorUpdate`] may still be provided, which must
383 still be processed by a running [`ChannelMonitor`]. This final update will mark the
384 [`ChannelMonitor`] as finalized, ensuring no further updates (e.g. revocation of the latest
385 commitment transaction) are allowed.
387 Note that even if you return a [`PermanentFailure`] due to unavailability of secondary
388 [`ChannelMonitor`] copies, you should still make an attempt to store the update where
389 possible to ensure you can claim HTLC outputs on the latest commitment transaction
392 In case of distributed watchtowers deployment, the new version must be written to disk, as
393 state may have been stored but rejected due to a block forcing a commitment broadcast. This
394 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
395 lagging behind on block processing.
397 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
398 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
400 LDKChannelMonitorUpdateStatus_PermanentFailure,
405 * An enum that represents the speed at which we want a transaction to confirm used for feerate
408 export enum ConfirmationTarget {
410 * We are happy with this transaction confirming slowly when feerate drops some.
412 LDKConfirmationTarget_Background,
414 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
416 LDKConfirmationTarget_Normal,
418 * We'd like this transaction to confirm in the next few blocks.
420 LDKConfirmationTarget_HighPriority,
425 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
427 export enum CreationError {
429 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
431 LDKCreationError_DescriptionTooLong,
433 * The specified route has too many hops and can't be encoded
435 LDKCreationError_RouteTooLong,
437 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
439 LDKCreationError_TimestampOutOfBounds,
441 * The supplied millisatoshi amount was greater than the total bitcoin supply.
443 LDKCreationError_InvalidAmount,
445 * Route hints were required for this invoice and were missing. Applies to
448 [phantom invoices]: crate::utils::create_phantom_invoice
450 LDKCreationError_MissingRouteHints,
455 * Enum representing the crypto currencies (or networks) supported by this library
457 export enum Currency {
465 LDKCurrency_BitcoinTestnet,
482 * Describes the type of HTLC claim as determined by analyzing the witness.
484 export enum HTLCClaim {
486 * Claims an offered output on a commitment transaction through the timeout path.
488 LDKHTLCClaim_OfferedTimeout,
490 * Claims an offered output on a commitment transaction through the success path.
492 LDKHTLCClaim_OfferedPreimage,
494 * Claims an accepted output on a commitment transaction through the timeout path.
496 LDKHTLCClaim_AcceptedTimeout,
498 * Claims an accepted output on a commitment transaction through the success path.
500 LDKHTLCClaim_AcceptedPreimage,
502 * Claims an offered/accepted output on a commitment transaction through the revocation path.
504 LDKHTLCClaim_Revocation,
509 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
511 export enum IOError {
513 LDKIOError_PermissionDenied,
514 LDKIOError_ConnectionRefused,
515 LDKIOError_ConnectionReset,
516 LDKIOError_ConnectionAborted,
517 LDKIOError_NotConnected,
518 LDKIOError_AddrInUse,
519 LDKIOError_AddrNotAvailable,
520 LDKIOError_BrokenPipe,
521 LDKIOError_AlreadyExists,
522 LDKIOError_WouldBlock,
523 LDKIOError_InvalidInput,
524 LDKIOError_InvalidData,
526 LDKIOError_WriteZero,
527 LDKIOError_Interrupted,
529 LDKIOError_UnexpectedEof,
534 * An enum representing the available verbosity levels of the logger.
538 * Designates extremely verbose information, including gossip-induced messages
542 * Designates very low priority, often extremely verbose, information
546 * Designates lower priority information
550 * Designates useful information
554 * Designates hazardous situations
558 * Designates very serious errors
565 * An enum representing the possible Bitcoin or test networks which we can run on
567 export enum Network {
569 * The main Bitcoin blockchain.
573 * The testnet3 blockchain.
577 * A local test blockchain.
581 * A blockchain on which blocks are signed instead of mined.
588 * Specifies the recipient of an invoice.
590 * This indicates to [`KeysInterface::sign_invoice`] what node secret key should be used to sign
593 export enum Recipient {
595 * The invoice should be signed with the local node secret key.
599 * The invoice should be signed with the phantom node secret key. This secret key must be the
600 same for all nodes participating in the [phantom node payment].
602 [phantom node payment]: PhantomKeysManager
604 LDKRecipient_PhantomNode,
609 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
611 export enum Secp256k1Error {
613 * Signature failed verification
615 LDKSecp256k1Error_IncorrectSignature,
617 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
619 LDKSecp256k1Error_InvalidMessage,
623 LDKSecp256k1Error_InvalidPublicKey,
627 LDKSecp256k1Error_InvalidSignature,
631 LDKSecp256k1Error_InvalidSecretKey,
635 LDKSecp256k1Error_InvalidSharedSecret,
639 LDKSecp256k1Error_InvalidRecoveryId,
641 * Invalid tweak for add_assign or mul_assign
643 LDKSecp256k1Error_InvalidTweak,
645 * Didn't pass enough memory to context creation with preallocated memory
647 LDKSecp256k1Error_NotEnoughMemory,
649 * Bad set of public keys.
651 LDKSecp256k1Error_InvalidPublicKeySum,
653 * The only valid parity values are 0 or 1.
655 LDKSecp256k1Error_InvalidParityValue,
660 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
661 * requirements sections in BOLT #11
663 export enum SemanticError {
665 * The invoice is missing the mandatory payment hash
667 LDKSemanticError_NoPaymentHash,
669 * The invoice has multiple payment hashes which isn't allowed
671 LDKSemanticError_MultiplePaymentHashes,
673 * No description or description hash are part of the invoice
675 LDKSemanticError_NoDescription,
677 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
679 LDKSemanticError_MultipleDescriptions,
681 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
684 LDKSemanticError_NoPaymentSecret,
686 * The invoice contains multiple payment secrets
688 LDKSemanticError_MultiplePaymentSecrets,
690 * The invoice's features are invalid
692 LDKSemanticError_InvalidFeatures,
694 * The recovery id doesn't fit the signature/pub key
696 LDKSemanticError_InvalidRecoveryId,
698 * The invoice's signature is invalid
700 LDKSemanticError_InvalidSignature,
702 * The invoice's amount was not a whole number of millisatoshis
704 LDKSemanticError_ImpreciseAmount,
709 * SI prefixes for the human readable part
711 export enum SiPrefix {
730 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
732 export function BigEndianScalar_get_bytes(thing: bigint): number {
733 if(!isWasmInitialized) {
734 throw new Error("initializeWasm() must be awaited first!");
736 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
737 return nativeResponseValue;
739 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
741 export function BigEndianScalar_free(thing: bigint): void {
742 if(!isWasmInitialized) {
743 throw new Error("initializeWasm() must be awaited first!");
745 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
746 // debug statements here
749 export class LDKBech32Error {
750 protected constructor() {}
753 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
754 if(!isWasmInitialized) {
755 throw new Error("initializeWasm() must be awaited first!");
757 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
758 return nativeResponseValue;
761 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
762 if(!isWasmInitialized) {
763 throw new Error("initializeWasm() must be awaited first!");
765 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
766 return nativeResponseValue;
769 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
770 if(!isWasmInitialized) {
771 throw new Error("initializeWasm() must be awaited first!");
773 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
774 return nativeResponseValue;
776 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
778 export function TxOut_get_script_pubkey(thing: bigint): number {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
783 return nativeResponseValue;
785 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
787 export function TxOut_get_value(thing: bigint): bigint {
788 if(!isWasmInitialized) {
789 throw new Error("initializeWasm() must be awaited first!");
791 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
792 return nativeResponseValue;
795 export class LDKCOption_HTLCClaimZ {
796 protected constructor() {}
799 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
800 if(!isWasmInitialized) {
801 throw new Error("initializeWasm() must be awaited first!");
803 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
804 return nativeResponseValue;
807 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
808 if(!isWasmInitialized) {
809 throw new Error("initializeWasm() must be awaited first!");
811 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
812 return nativeResponseValue;
814 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
816 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
817 if(!isWasmInitialized) {
818 throw new Error("initializeWasm() must be awaited first!");
820 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
821 // debug statements here
823 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
825 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
826 if(!isWasmInitialized) {
827 throw new Error("initializeWasm() must be awaited first!");
829 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
830 // debug statements here
833 export class LDKDecodeError {
834 protected constructor() {}
837 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
838 if(!isWasmInitialized) {
839 throw new Error("initializeWasm() must be awaited first!");
841 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
842 return nativeResponseValue;
845 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
846 if(!isWasmInitialized) {
847 throw new Error("initializeWasm() must be awaited first!");
849 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
850 return nativeResponseValue;
852 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
854 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
855 if(!isWasmInitialized) {
856 throw new Error("initializeWasm() must be awaited first!");
858 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
859 return nativeResponseValue;
861 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
863 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
864 if(!isWasmInitialized) {
865 throw new Error("initializeWasm() must be awaited first!");
867 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
868 return nativeResponseValue;
870 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
872 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
873 if(!isWasmInitialized) {
874 throw new Error("initializeWasm() must be awaited first!");
876 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
877 return nativeResponseValue;
879 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
881 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
882 if(!isWasmInitialized) {
883 throw new Error("initializeWasm() must be awaited first!");
885 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
886 return nativeResponseValue;
888 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
890 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
891 if(!isWasmInitialized) {
892 throw new Error("initializeWasm() must be awaited first!");
894 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
895 return nativeResponseValue;
897 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
899 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
900 if(!isWasmInitialized) {
901 throw new Error("initializeWasm() must be awaited first!");
903 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
904 return nativeResponseValue;
907 export class LDKCOption_u32Z {
908 protected constructor() {}
911 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
912 if(!isWasmInitialized) {
913 throw new Error("initializeWasm() must be awaited first!");
915 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
916 return nativeResponseValue;
919 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
920 if(!isWasmInitialized) {
921 throw new Error("initializeWasm() must be awaited first!");
923 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
924 return nativeResponseValue;
926 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
928 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
929 if(!isWasmInitialized) {
930 throw new Error("initializeWasm() must be awaited first!");
932 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
933 return nativeResponseValue;
935 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
937 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
938 if(!isWasmInitialized) {
939 throw new Error("initializeWasm() must be awaited first!");
941 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
942 return nativeResponseValue;
944 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
946 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
947 if(!isWasmInitialized) {
948 throw new Error("initializeWasm() must be awaited first!");
950 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
951 return nativeResponseValue;
953 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
955 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
956 if(!isWasmInitialized) {
957 throw new Error("initializeWasm() must be awaited first!");
959 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
960 return nativeResponseValue;
962 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
964 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
965 if(!isWasmInitialized) {
966 throw new Error("initializeWasm() must be awaited first!");
968 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
969 return nativeResponseValue;
971 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
973 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
974 if(!isWasmInitialized) {
975 throw new Error("initializeWasm() must be awaited first!");
977 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
978 return nativeResponseValue;
980 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
982 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
983 if(!isWasmInitialized) {
984 throw new Error("initializeWasm() must be awaited first!");
986 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
987 return nativeResponseValue;
989 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
991 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
992 if(!isWasmInitialized) {
993 throw new Error("initializeWasm() must be awaited first!");
995 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
996 return nativeResponseValue;
998 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1000 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1001 if(!isWasmInitialized) {
1002 throw new Error("initializeWasm() must be awaited first!");
1004 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
1005 return nativeResponseValue;
1007 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1009 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1010 if(!isWasmInitialized) {
1011 throw new Error("initializeWasm() must be awaited first!");
1013 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
1014 return nativeResponseValue;
1016 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1018 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
1019 if(!isWasmInitialized) {
1020 throw new Error("initializeWasm() must be awaited first!");
1022 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
1023 return nativeResponseValue;
1025 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1027 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
1028 if(!isWasmInitialized) {
1029 throw new Error("initializeWasm() must be awaited first!");
1031 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
1032 // debug statements here
1034 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1036 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1037 if(!isWasmInitialized) {
1038 throw new Error("initializeWasm() must be awaited first!");
1040 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
1041 return nativeResponseValue;
1043 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1045 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1046 if(!isWasmInitialized) {
1047 throw new Error("initializeWasm() must be awaited first!");
1049 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
1050 return nativeResponseValue;
1052 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1054 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
1055 if(!isWasmInitialized) {
1056 throw new Error("initializeWasm() must be awaited first!");
1058 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
1059 return nativeResponseValue;
1061 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1063 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
1064 if(!isWasmInitialized) {
1065 throw new Error("initializeWasm() must be awaited first!");
1067 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
1068 // debug statements here
1070 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1072 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
1073 if(!isWasmInitialized) {
1074 throw new Error("initializeWasm() must be awaited first!");
1076 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1077 return nativeResponseValue;
1079 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1081 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1082 if(!isWasmInitialized) {
1083 throw new Error("initializeWasm() must be awaited first!");
1085 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1086 // debug statements here
1088 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1090 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1091 if(!isWasmInitialized) {
1092 throw new Error("initializeWasm() must be awaited first!");
1094 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1095 return nativeResponseValue;
1097 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1099 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1100 if(!isWasmInitialized) {
1101 throw new Error("initializeWasm() must be awaited first!");
1103 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1104 return nativeResponseValue;
1106 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1108 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1109 if(!isWasmInitialized) {
1110 throw new Error("initializeWasm() must be awaited first!");
1112 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1113 return nativeResponseValue;
1115 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1117 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1118 if(!isWasmInitialized) {
1119 throw new Error("initializeWasm() must be awaited first!");
1121 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1122 return nativeResponseValue;
1124 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
1126 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
1127 if(!isWasmInitialized) {
1128 throw new Error("initializeWasm() must be awaited first!");
1130 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
1131 return nativeResponseValue;
1133 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
1135 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
1136 if(!isWasmInitialized) {
1137 throw new Error("initializeWasm() must be awaited first!");
1139 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
1140 // debug statements here
1142 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
1144 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
1145 if(!isWasmInitialized) {
1146 throw new Error("initializeWasm() must be awaited first!");
1148 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
1149 return nativeResponseValue;
1151 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
1153 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
1154 if(!isWasmInitialized) {
1155 throw new Error("initializeWasm() must be awaited first!");
1157 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
1158 return nativeResponseValue;
1160 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
1162 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1163 if(!isWasmInitialized) {
1164 throw new Error("initializeWasm() must be awaited first!");
1166 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
1167 return nativeResponseValue;
1169 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
1171 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
1172 if(!isWasmInitialized) {
1173 throw new Error("initializeWasm() must be awaited first!");
1175 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
1176 return nativeResponseValue;
1178 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1180 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
1181 if(!isWasmInitialized) {
1182 throw new Error("initializeWasm() must be awaited first!");
1184 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1185 return nativeResponseValue;
1187 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1189 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
1190 if(!isWasmInitialized) {
1191 throw new Error("initializeWasm() must be awaited first!");
1193 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1194 return nativeResponseValue;
1197 export class LDKCOption_u64Z {
1198 protected constructor() {}
1201 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1202 if(!isWasmInitialized) {
1203 throw new Error("initializeWasm() must be awaited first!");
1205 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1206 return nativeResponseValue;
1209 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1210 if(!isWasmInitialized) {
1211 throw new Error("initializeWasm() must be awaited first!");
1213 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1214 return nativeResponseValue;
1216 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
1218 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
1219 if(!isWasmInitialized) {
1220 throw new Error("initializeWasm() must be awaited first!");
1222 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
1223 return nativeResponseValue;
1225 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
1227 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
1228 if(!isWasmInitialized) {
1229 throw new Error("initializeWasm() must be awaited first!");
1231 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
1232 return nativeResponseValue;
1234 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1236 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1237 if(!isWasmInitialized) {
1238 throw new Error("initializeWasm() must be awaited first!");
1240 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1241 return nativeResponseValue;
1243 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1245 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
1246 if(!isWasmInitialized) {
1247 throw new Error("initializeWasm() must be awaited first!");
1249 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1250 return nativeResponseValue;
1252 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1254 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
1255 if(!isWasmInitialized) {
1256 throw new Error("initializeWasm() must be awaited first!");
1258 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1259 return nativeResponseValue;
1261 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1263 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
1264 if(!isWasmInitialized) {
1265 throw new Error("initializeWasm() must be awaited first!");
1267 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1268 return nativeResponseValue;
1270 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1272 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1273 if(!isWasmInitialized) {
1274 throw new Error("initializeWasm() must be awaited first!");
1276 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1277 return nativeResponseValue;
1279 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1281 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1282 if(!isWasmInitialized) {
1283 throw new Error("initializeWasm() must be awaited first!");
1285 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1286 return nativeResponseValue;
1288 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1290 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1291 if(!isWasmInitialized) {
1292 throw new Error("initializeWasm() must be awaited first!");
1294 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1295 return nativeResponseValue;
1297 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1299 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1300 if(!isWasmInitialized) {
1301 throw new Error("initializeWasm() must be awaited first!");
1303 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1304 return nativeResponseValue;
1306 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1308 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
1309 if(!isWasmInitialized) {
1310 throw new Error("initializeWasm() must be awaited first!");
1312 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1313 return nativeResponseValue;
1315 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1317 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
1318 if(!isWasmInitialized) {
1319 throw new Error("initializeWasm() must be awaited first!");
1321 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1322 return nativeResponseValue;
1324 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1326 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1327 if(!isWasmInitialized) {
1328 throw new Error("initializeWasm() must be awaited first!");
1330 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1331 return nativeResponseValue;
1333 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1335 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
1336 if(!isWasmInitialized) {
1337 throw new Error("initializeWasm() must be awaited first!");
1339 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1340 return nativeResponseValue;
1343 export class LDKPaymentPurpose {
1344 protected constructor() {}
1347 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
1348 if(!isWasmInitialized) {
1349 throw new Error("initializeWasm() must be awaited first!");
1351 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1352 return nativeResponseValue;
1355 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
1356 if(!isWasmInitialized) {
1357 throw new Error("initializeWasm() must be awaited first!");
1359 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1360 return nativeResponseValue;
1363 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1368 return nativeResponseValue;
1371 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1376 return nativeResponseValue;
1378 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1380 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
1381 if(!isWasmInitialized) {
1382 throw new Error("initializeWasm() must be awaited first!");
1384 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1385 return nativeResponseValue;
1387 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1389 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
1390 if(!isWasmInitialized) {
1391 throw new Error("initializeWasm() must be awaited first!");
1393 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1394 return nativeResponseValue;
1397 export class LDKClosureReason {
1398 protected constructor() {}
1401 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
1402 if(!isWasmInitialized) {
1403 throw new Error("initializeWasm() must be awaited first!");
1405 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1406 return nativeResponseValue;
1409 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
1410 if(!isWasmInitialized) {
1411 throw new Error("initializeWasm() must be awaited first!");
1413 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1414 return nativeResponseValue;
1417 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
1418 if(!isWasmInitialized) {
1419 throw new Error("initializeWasm() must be awaited first!");
1421 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1422 return nativeResponseValue;
1425 export class LDKCOption_ClosureReasonZ {
1426 protected constructor() {}
1429 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
1430 if(!isWasmInitialized) {
1431 throw new Error("initializeWasm() must be awaited first!");
1433 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1434 return nativeResponseValue;
1437 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
1438 if(!isWasmInitialized) {
1439 throw new Error("initializeWasm() must be awaited first!");
1441 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1442 return nativeResponseValue;
1444 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1446 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
1447 if(!isWasmInitialized) {
1448 throw new Error("initializeWasm() must be awaited first!");
1450 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1451 return nativeResponseValue;
1453 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1455 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
1456 if(!isWasmInitialized) {
1457 throw new Error("initializeWasm() must be awaited first!");
1459 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1460 return nativeResponseValue;
1463 export class LDKHTLCDestination {
1464 protected constructor() {}
1467 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
1468 if(!isWasmInitialized) {
1469 throw new Error("initializeWasm() must be awaited first!");
1471 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1472 return nativeResponseValue;
1475 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
1476 if(!isWasmInitialized) {
1477 throw new Error("initializeWasm() must be awaited first!");
1479 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1480 return nativeResponseValue;
1483 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
1484 if(!isWasmInitialized) {
1485 throw new Error("initializeWasm() must be awaited first!");
1487 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1488 return nativeResponseValue;
1491 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
1492 if(!isWasmInitialized) {
1493 throw new Error("initializeWasm() must be awaited first!");
1495 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1496 return nativeResponseValue;
1499 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
1500 if(!isWasmInitialized) {
1501 throw new Error("initializeWasm() must be awaited first!");
1503 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
1504 return nativeResponseValue;
1507 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
1508 if(!isWasmInitialized) {
1509 throw new Error("initializeWasm() must be awaited first!");
1511 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1512 return nativeResponseValue;
1515 export class LDKCOption_HTLCDestinationZ {
1516 protected constructor() {}
1519 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
1520 if(!isWasmInitialized) {
1521 throw new Error("initializeWasm() must be awaited first!");
1523 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1524 return nativeResponseValue;
1527 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
1528 if(!isWasmInitialized) {
1529 throw new Error("initializeWasm() must be awaited first!");
1531 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1532 return nativeResponseValue;
1534 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1536 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
1537 if(!isWasmInitialized) {
1538 throw new Error("initializeWasm() must be awaited first!");
1540 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1541 return nativeResponseValue;
1543 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1545 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
1546 if(!isWasmInitialized) {
1547 throw new Error("initializeWasm() must be awaited first!");
1549 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1550 return nativeResponseValue;
1553 export class LDKCOption_u128Z {
1554 protected constructor() {}
1557 export function LDKCOption_u128Z_ty_from_ptr(ptr: bigint): number {
1558 if(!isWasmInitialized) {
1559 throw new Error("initializeWasm() must be awaited first!");
1561 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_ty_from_ptr(ptr);
1562 return nativeResponseValue;
1565 export function LDKCOption_u128Z_Some_get_some(ptr: bigint): number {
1566 if(!isWasmInitialized) {
1567 throw new Error("initializeWasm() must be awaited first!");
1569 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_Some_get_some(ptr);
1570 return nativeResponseValue;
1573 export class LDKNetworkUpdate {
1574 protected constructor() {}
1577 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
1578 if(!isWasmInitialized) {
1579 throw new Error("initializeWasm() must be awaited first!");
1581 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1582 return nativeResponseValue;
1585 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
1586 if(!isWasmInitialized) {
1587 throw new Error("initializeWasm() must be awaited first!");
1589 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1590 return nativeResponseValue;
1593 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
1594 if(!isWasmInitialized) {
1595 throw new Error("initializeWasm() must be awaited first!");
1597 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1598 return nativeResponseValue;
1601 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
1602 if(!isWasmInitialized) {
1603 throw new Error("initializeWasm() must be awaited first!");
1605 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1606 return nativeResponseValue;
1609 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
1610 if(!isWasmInitialized) {
1611 throw new Error("initializeWasm() must be awaited first!");
1613 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1614 return nativeResponseValue;
1617 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
1618 if(!isWasmInitialized) {
1619 throw new Error("initializeWasm() must be awaited first!");
1621 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1622 return nativeResponseValue;
1625 export class LDKCOption_NetworkUpdateZ {
1626 protected constructor() {}
1629 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
1630 if(!isWasmInitialized) {
1631 throw new Error("initializeWasm() must be awaited first!");
1633 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1634 return nativeResponseValue;
1637 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
1638 if(!isWasmInitialized) {
1639 throw new Error("initializeWasm() must be awaited first!");
1641 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1642 return nativeResponseValue;
1645 export class LDKSpendableOutputDescriptor {
1646 protected constructor() {}
1649 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1650 if(!isWasmInitialized) {
1651 throw new Error("initializeWasm() must be awaited first!");
1653 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1654 return nativeResponseValue;
1657 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1658 if(!isWasmInitialized) {
1659 throw new Error("initializeWasm() must be awaited first!");
1661 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1662 return nativeResponseValue;
1665 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1666 if(!isWasmInitialized) {
1667 throw new Error("initializeWasm() must be awaited first!");
1669 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1670 return nativeResponseValue;
1673 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1674 if(!isWasmInitialized) {
1675 throw new Error("initializeWasm() must be awaited first!");
1677 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1678 return nativeResponseValue;
1681 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1682 if(!isWasmInitialized) {
1683 throw new Error("initializeWasm() must be awaited first!");
1685 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1686 return nativeResponseValue;
1689 export class LDKEvent {
1690 protected constructor() {}
1693 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
1694 if(!isWasmInitialized) {
1695 throw new Error("initializeWasm() must be awaited first!");
1697 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1698 return nativeResponseValue;
1701 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
1702 if(!isWasmInitialized) {
1703 throw new Error("initializeWasm() must be awaited first!");
1705 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1706 return nativeResponseValue;
1709 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
1710 if(!isWasmInitialized) {
1711 throw new Error("initializeWasm() must be awaited first!");
1713 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1714 return nativeResponseValue;
1717 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
1718 if(!isWasmInitialized) {
1719 throw new Error("initializeWasm() must be awaited first!");
1721 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1722 return nativeResponseValue;
1725 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
1726 if(!isWasmInitialized) {
1727 throw new Error("initializeWasm() must be awaited first!");
1729 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1730 return nativeResponseValue;
1733 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
1734 if(!isWasmInitialized) {
1735 throw new Error("initializeWasm() must be awaited first!");
1737 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1738 return nativeResponseValue;
1741 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
1746 return nativeResponseValue;
1749 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
1750 if(!isWasmInitialized) {
1751 throw new Error("initializeWasm() must be awaited first!");
1753 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
1754 return nativeResponseValue;
1757 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
1758 if(!isWasmInitialized) {
1759 throw new Error("initializeWasm() must be awaited first!");
1761 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
1762 return nativeResponseValue;
1765 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
1766 if(!isWasmInitialized) {
1767 throw new Error("initializeWasm() must be awaited first!");
1769 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
1770 return nativeResponseValue;
1773 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): number {
1774 if(!isWasmInitialized) {
1775 throw new Error("initializeWasm() must be awaited first!");
1777 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
1778 return nativeResponseValue;
1781 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
1782 if(!isWasmInitialized) {
1783 throw new Error("initializeWasm() must be awaited first!");
1785 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
1786 return nativeResponseValue;
1789 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
1790 if(!isWasmInitialized) {
1791 throw new Error("initializeWasm() must be awaited first!");
1793 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
1794 return nativeResponseValue;
1797 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
1798 if(!isWasmInitialized) {
1799 throw new Error("initializeWasm() must be awaited first!");
1801 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1802 return nativeResponseValue;
1805 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
1806 if(!isWasmInitialized) {
1807 throw new Error("initializeWasm() must be awaited first!");
1809 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1810 return nativeResponseValue;
1813 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
1814 if(!isWasmInitialized) {
1815 throw new Error("initializeWasm() must be awaited first!");
1817 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1818 return nativeResponseValue;
1821 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): number {
1822 if(!isWasmInitialized) {
1823 throw new Error("initializeWasm() must be awaited first!");
1825 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1826 return nativeResponseValue;
1829 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
1830 if(!isWasmInitialized) {
1831 throw new Error("initializeWasm() must be awaited first!");
1833 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1834 return nativeResponseValue;
1837 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
1838 if(!isWasmInitialized) {
1839 throw new Error("initializeWasm() must be awaited first!");
1841 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1842 return nativeResponseValue;
1845 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
1846 if(!isWasmInitialized) {
1847 throw new Error("initializeWasm() must be awaited first!");
1849 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1850 return nativeResponseValue;
1853 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
1854 if(!isWasmInitialized) {
1855 throw new Error("initializeWasm() must be awaited first!");
1857 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1858 return nativeResponseValue;
1861 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
1862 if(!isWasmInitialized) {
1863 throw new Error("initializeWasm() must be awaited first!");
1865 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1866 return nativeResponseValue;
1869 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
1870 if(!isWasmInitialized) {
1871 throw new Error("initializeWasm() must be awaited first!");
1873 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1874 return nativeResponseValue;
1877 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): number {
1878 if(!isWasmInitialized) {
1879 throw new Error("initializeWasm() must be awaited first!");
1881 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1882 return nativeResponseValue;
1885 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
1886 if(!isWasmInitialized) {
1887 throw new Error("initializeWasm() must be awaited first!");
1889 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1890 return nativeResponseValue;
1893 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): number {
1894 if(!isWasmInitialized) {
1895 throw new Error("initializeWasm() must be awaited first!");
1897 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1898 return nativeResponseValue;
1901 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
1902 if(!isWasmInitialized) {
1903 throw new Error("initializeWasm() must be awaited first!");
1905 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1906 return nativeResponseValue;
1909 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
1910 if(!isWasmInitialized) {
1911 throw new Error("initializeWasm() must be awaited first!");
1913 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
1914 return nativeResponseValue;
1917 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: bigint): bigint {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1922 return nativeResponseValue;
1925 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: bigint): boolean {
1926 if(!isWasmInitialized) {
1927 throw new Error("initializeWasm() must be awaited first!");
1929 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1930 return nativeResponseValue;
1933 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1938 return nativeResponseValue;
1941 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1946 return nativeResponseValue;
1949 export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
1950 if(!isWasmInitialized) {
1951 throw new Error("initializeWasm() must be awaited first!");
1953 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1954 return nativeResponseValue;
1957 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
1958 if(!isWasmInitialized) {
1959 throw new Error("initializeWasm() must be awaited first!");
1961 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1962 return nativeResponseValue;
1965 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
1966 if(!isWasmInitialized) {
1967 throw new Error("initializeWasm() must be awaited first!");
1969 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1970 return nativeResponseValue;
1973 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
1974 if(!isWasmInitialized) {
1975 throw new Error("initializeWasm() must be awaited first!");
1977 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1978 return nativeResponseValue;
1981 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
1982 if(!isWasmInitialized) {
1983 throw new Error("initializeWasm() must be awaited first!");
1985 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1986 return nativeResponseValue;
1989 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
1990 if(!isWasmInitialized) {
1991 throw new Error("initializeWasm() must be awaited first!");
1993 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1994 return nativeResponseValue;
1997 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
1998 if(!isWasmInitialized) {
1999 throw new Error("initializeWasm() must be awaited first!");
2001 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
2002 return nativeResponseValue;
2005 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
2006 if(!isWasmInitialized) {
2007 throw new Error("initializeWasm() must be awaited first!");
2009 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
2010 return nativeResponseValue;
2013 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
2018 return nativeResponseValue;
2021 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
2022 if(!isWasmInitialized) {
2023 throw new Error("initializeWasm() must be awaited first!");
2025 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
2026 return nativeResponseValue;
2029 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
2030 if(!isWasmInitialized) {
2031 throw new Error("initializeWasm() must be awaited first!");
2033 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
2034 return nativeResponseValue;
2037 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
2038 if(!isWasmInitialized) {
2039 throw new Error("initializeWasm() must be awaited first!");
2041 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
2042 return nativeResponseValue;
2045 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
2046 if(!isWasmInitialized) {
2047 throw new Error("initializeWasm() must be awaited first!");
2049 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
2050 return nativeResponseValue;
2053 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
2054 if(!isWasmInitialized) {
2055 throw new Error("initializeWasm() must be awaited first!");
2057 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
2058 return nativeResponseValue;
2061 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
2062 if(!isWasmInitialized) {
2063 throw new Error("initializeWasm() must be awaited first!");
2065 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
2066 return nativeResponseValue;
2069 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
2070 if(!isWasmInitialized) {
2071 throw new Error("initializeWasm() must be awaited first!");
2073 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
2074 return nativeResponseValue;
2077 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
2078 if(!isWasmInitialized) {
2079 throw new Error("initializeWasm() must be awaited first!");
2081 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
2082 return nativeResponseValue;
2085 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
2086 if(!isWasmInitialized) {
2087 throw new Error("initializeWasm() must be awaited first!");
2089 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
2090 return nativeResponseValue;
2093 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
2094 if(!isWasmInitialized) {
2095 throw new Error("initializeWasm() must be awaited first!");
2097 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
2098 return nativeResponseValue;
2101 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
2102 if(!isWasmInitialized) {
2103 throw new Error("initializeWasm() must be awaited first!");
2105 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
2106 return nativeResponseValue;
2109 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
2110 if(!isWasmInitialized) {
2111 throw new Error("initializeWasm() must be awaited first!");
2113 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
2114 return nativeResponseValue;
2117 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
2118 if(!isWasmInitialized) {
2119 throw new Error("initializeWasm() must be awaited first!");
2121 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
2122 return nativeResponseValue;
2125 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
2126 if(!isWasmInitialized) {
2127 throw new Error("initializeWasm() must be awaited first!");
2129 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
2130 return nativeResponseValue;
2133 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
2134 if(!isWasmInitialized) {
2135 throw new Error("initializeWasm() must be awaited first!");
2137 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
2138 return nativeResponseValue;
2141 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
2142 if(!isWasmInitialized) {
2143 throw new Error("initializeWasm() must be awaited first!");
2145 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
2146 return nativeResponseValue;
2149 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
2150 if(!isWasmInitialized) {
2151 throw new Error("initializeWasm() must be awaited first!");
2153 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
2154 return nativeResponseValue;
2157 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
2158 if(!isWasmInitialized) {
2159 throw new Error("initializeWasm() must be awaited first!");
2161 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
2162 return nativeResponseValue;
2165 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
2166 if(!isWasmInitialized) {
2167 throw new Error("initializeWasm() must be awaited first!");
2169 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
2170 return nativeResponseValue;
2173 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
2174 if(!isWasmInitialized) {
2175 throw new Error("initializeWasm() must be awaited first!");
2177 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
2178 return nativeResponseValue;
2181 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
2182 if(!isWasmInitialized) {
2183 throw new Error("initializeWasm() must be awaited first!");
2185 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
2186 return nativeResponseValue;
2189 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
2190 if(!isWasmInitialized) {
2191 throw new Error("initializeWasm() must be awaited first!");
2193 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
2194 return nativeResponseValue;
2197 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
2198 if(!isWasmInitialized) {
2199 throw new Error("initializeWasm() must be awaited first!");
2201 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
2202 return nativeResponseValue;
2205 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
2206 if(!isWasmInitialized) {
2207 throw new Error("initializeWasm() must be awaited first!");
2209 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
2210 return nativeResponseValue;
2213 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
2214 if(!isWasmInitialized) {
2215 throw new Error("initializeWasm() must be awaited first!");
2217 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
2218 return nativeResponseValue;
2221 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
2222 if(!isWasmInitialized) {
2223 throw new Error("initializeWasm() must be awaited first!");
2225 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
2226 return nativeResponseValue;
2229 export class LDKCOption_EventZ {
2230 protected constructor() {}
2233 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
2234 if(!isWasmInitialized) {
2235 throw new Error("initializeWasm() must be awaited first!");
2237 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2238 return nativeResponseValue;
2241 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
2242 if(!isWasmInitialized) {
2243 throw new Error("initializeWasm() must be awaited first!");
2245 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2246 return nativeResponseValue;
2248 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2250 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
2251 if(!isWasmInitialized) {
2252 throw new Error("initializeWasm() must be awaited first!");
2254 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2255 return nativeResponseValue;
2257 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2259 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
2260 if(!isWasmInitialized) {
2261 throw new Error("initializeWasm() must be awaited first!");
2263 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2264 return nativeResponseValue;
2267 export class LDKErrorAction {
2268 protected constructor() {}
2271 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2276 return nativeResponseValue;
2279 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
2280 if(!isWasmInitialized) {
2281 throw new Error("initializeWasm() must be awaited first!");
2283 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2284 return nativeResponseValue;
2287 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
2288 if(!isWasmInitialized) {
2289 throw new Error("initializeWasm() must be awaited first!");
2291 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2292 return nativeResponseValue;
2295 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
2296 if(!isWasmInitialized) {
2297 throw new Error("initializeWasm() must be awaited first!");
2299 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2300 return nativeResponseValue;
2303 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
2304 if(!isWasmInitialized) {
2305 throw new Error("initializeWasm() must be awaited first!");
2307 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2308 return nativeResponseValue;
2311 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
2312 if(!isWasmInitialized) {
2313 throw new Error("initializeWasm() must be awaited first!");
2315 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2316 return nativeResponseValue;
2319 export class LDKMessageSendEvent {
2320 protected constructor() {}
2323 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
2324 if(!isWasmInitialized) {
2325 throw new Error("initializeWasm() must be awaited first!");
2327 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2328 return nativeResponseValue;
2331 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
2332 if(!isWasmInitialized) {
2333 throw new Error("initializeWasm() must be awaited first!");
2335 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2336 return nativeResponseValue;
2339 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
2340 if(!isWasmInitialized) {
2341 throw new Error("initializeWasm() must be awaited first!");
2343 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2344 return nativeResponseValue;
2347 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
2348 if(!isWasmInitialized) {
2349 throw new Error("initializeWasm() must be awaited first!");
2351 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2352 return nativeResponseValue;
2355 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
2356 if(!isWasmInitialized) {
2357 throw new Error("initializeWasm() must be awaited first!");
2359 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2360 return nativeResponseValue;
2363 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
2364 if(!isWasmInitialized) {
2365 throw new Error("initializeWasm() must be awaited first!");
2367 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2368 return nativeResponseValue;
2371 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
2372 if(!isWasmInitialized) {
2373 throw new Error("initializeWasm() must be awaited first!");
2375 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2376 return nativeResponseValue;
2379 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
2380 if(!isWasmInitialized) {
2381 throw new Error("initializeWasm() must be awaited first!");
2383 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2384 return nativeResponseValue;
2387 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
2388 if(!isWasmInitialized) {
2389 throw new Error("initializeWasm() must be awaited first!");
2391 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2392 return nativeResponseValue;
2395 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
2396 if(!isWasmInitialized) {
2397 throw new Error("initializeWasm() must be awaited first!");
2399 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2400 return nativeResponseValue;
2403 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
2404 if(!isWasmInitialized) {
2405 throw new Error("initializeWasm() must be awaited first!");
2407 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2408 return nativeResponseValue;
2411 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
2412 if(!isWasmInitialized) {
2413 throw new Error("initializeWasm() must be awaited first!");
2415 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2416 return nativeResponseValue;
2419 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
2420 if(!isWasmInitialized) {
2421 throw new Error("initializeWasm() must be awaited first!");
2423 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2424 return nativeResponseValue;
2427 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
2428 if(!isWasmInitialized) {
2429 throw new Error("initializeWasm() must be awaited first!");
2431 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2432 return nativeResponseValue;
2435 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
2436 if(!isWasmInitialized) {
2437 throw new Error("initializeWasm() must be awaited first!");
2439 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2440 return nativeResponseValue;
2443 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
2444 if(!isWasmInitialized) {
2445 throw new Error("initializeWasm() must be awaited first!");
2447 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2448 return nativeResponseValue;
2451 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
2452 if(!isWasmInitialized) {
2453 throw new Error("initializeWasm() must be awaited first!");
2455 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2456 return nativeResponseValue;
2459 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
2460 if(!isWasmInitialized) {
2461 throw new Error("initializeWasm() must be awaited first!");
2463 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2464 return nativeResponseValue;
2467 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
2468 if(!isWasmInitialized) {
2469 throw new Error("initializeWasm() must be awaited first!");
2471 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2472 return nativeResponseValue;
2475 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
2476 if(!isWasmInitialized) {
2477 throw new Error("initializeWasm() must be awaited first!");
2479 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2480 return nativeResponseValue;
2483 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
2484 if(!isWasmInitialized) {
2485 throw new Error("initializeWasm() must be awaited first!");
2487 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2488 return nativeResponseValue;
2491 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
2492 if(!isWasmInitialized) {
2493 throw new Error("initializeWasm() must be awaited first!");
2495 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2496 return nativeResponseValue;
2499 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
2500 if(!isWasmInitialized) {
2501 throw new Error("initializeWasm() must be awaited first!");
2503 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2504 return nativeResponseValue;
2507 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
2508 if(!isWasmInitialized) {
2509 throw new Error("initializeWasm() must be awaited first!");
2511 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
2512 return nativeResponseValue;
2515 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
2516 if(!isWasmInitialized) {
2517 throw new Error("initializeWasm() must be awaited first!");
2519 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
2520 return nativeResponseValue;
2523 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2524 if(!isWasmInitialized) {
2525 throw new Error("initializeWasm() must be awaited first!");
2527 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
2528 return nativeResponseValue;
2531 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
2532 if(!isWasmInitialized) {
2533 throw new Error("initializeWasm() must be awaited first!");
2535 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2536 return nativeResponseValue;
2539 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2540 if(!isWasmInitialized) {
2541 throw new Error("initializeWasm() must be awaited first!");
2543 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2544 return nativeResponseValue;
2547 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
2548 if(!isWasmInitialized) {
2549 throw new Error("initializeWasm() must be awaited first!");
2551 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2552 return nativeResponseValue;
2555 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
2556 if(!isWasmInitialized) {
2557 throw new Error("initializeWasm() must be awaited first!");
2559 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2560 return nativeResponseValue;
2563 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
2564 if(!isWasmInitialized) {
2565 throw new Error("initializeWasm() must be awaited first!");
2567 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2568 return nativeResponseValue;
2571 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
2572 if(!isWasmInitialized) {
2573 throw new Error("initializeWasm() must be awaited first!");
2575 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2576 return nativeResponseValue;
2579 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2584 return nativeResponseValue;
2587 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
2588 if(!isWasmInitialized) {
2589 throw new Error("initializeWasm() must be awaited first!");
2591 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2592 return nativeResponseValue;
2595 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
2596 if(!isWasmInitialized) {
2597 throw new Error("initializeWasm() must be awaited first!");
2599 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2600 return nativeResponseValue;
2603 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
2604 if(!isWasmInitialized) {
2605 throw new Error("initializeWasm() must be awaited first!");
2607 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2608 return nativeResponseValue;
2611 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
2612 if(!isWasmInitialized) {
2613 throw new Error("initializeWasm() must be awaited first!");
2615 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2616 return nativeResponseValue;
2619 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
2620 if(!isWasmInitialized) {
2621 throw new Error("initializeWasm() must be awaited first!");
2623 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2624 return nativeResponseValue;
2627 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
2628 if(!isWasmInitialized) {
2629 throw new Error("initializeWasm() must be awaited first!");
2631 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2632 return nativeResponseValue;
2635 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
2636 if(!isWasmInitialized) {
2637 throw new Error("initializeWasm() must be awaited first!");
2639 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2640 return nativeResponseValue;
2643 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
2644 if(!isWasmInitialized) {
2645 throw new Error("initializeWasm() must be awaited first!");
2647 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2648 return nativeResponseValue;
2650 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2652 export function CResult_TxOutAccessErrorZ_get_ok(owner: bigint): bigint {
2653 if(!isWasmInitialized) {
2654 throw new Error("initializeWasm() must be awaited first!");
2656 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2657 return nativeResponseValue;
2659 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2661 export function CResult_TxOutAccessErrorZ_get_err(owner: bigint): AccessError {
2662 if(!isWasmInitialized) {
2663 throw new Error("initializeWasm() must be awaited first!");
2665 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2666 return nativeResponseValue;
2668 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2670 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2671 if(!isWasmInitialized) {
2672 throw new Error("initializeWasm() must be awaited first!");
2674 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2675 return nativeResponseValue;
2677 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2679 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2680 if(!isWasmInitialized) {
2681 throw new Error("initializeWasm() must be awaited first!");
2683 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2684 return nativeResponseValue;
2686 // struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
2688 export function C2Tuple_TxidBlockHashZ_get_a(owner: bigint): number {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_a(owner);
2693 return nativeResponseValue;
2695 // struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
2697 export function C2Tuple_TxidBlockHashZ_get_b(owner: bigint): number {
2698 if(!isWasmInitialized) {
2699 throw new Error("initializeWasm() must be awaited first!");
2701 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_b(owner);
2702 return nativeResponseValue;
2705 export class LDKMonitorEvent {
2706 protected constructor() {}
2709 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2710 if(!isWasmInitialized) {
2711 throw new Error("initializeWasm() must be awaited first!");
2713 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2714 return nativeResponseValue;
2717 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2718 if(!isWasmInitialized) {
2719 throw new Error("initializeWasm() must be awaited first!");
2721 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2722 return nativeResponseValue;
2725 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2726 if(!isWasmInitialized) {
2727 throw new Error("initializeWasm() must be awaited first!");
2729 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2730 return nativeResponseValue;
2733 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2738 return nativeResponseValue;
2741 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2742 if(!isWasmInitialized) {
2743 throw new Error("initializeWasm() must be awaited first!");
2745 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2746 return nativeResponseValue;
2749 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2750 if(!isWasmInitialized) {
2751 throw new Error("initializeWasm() must be awaited first!");
2753 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2754 return nativeResponseValue;
2756 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2758 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2759 if(!isWasmInitialized) {
2760 throw new Error("initializeWasm() must be awaited first!");
2762 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2763 return nativeResponseValue;
2765 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2767 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2768 if(!isWasmInitialized) {
2769 throw new Error("initializeWasm() must be awaited first!");
2771 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2772 return nativeResponseValue;
2774 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2776 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2777 if(!isWasmInitialized) {
2778 throw new Error("initializeWasm() must be awaited first!");
2780 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2781 return nativeResponseValue;
2783 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2785 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2786 if(!isWasmInitialized) {
2787 throw new Error("initializeWasm() must be awaited first!");
2789 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2790 return nativeResponseValue;
2792 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2794 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2795 if(!isWasmInitialized) {
2796 throw new Error("initializeWasm() must be awaited first!");
2798 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2799 return nativeResponseValue;
2801 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2803 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2804 if(!isWasmInitialized) {
2805 throw new Error("initializeWasm() must be awaited first!");
2807 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2808 return nativeResponseValue;
2810 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2812 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2813 if(!isWasmInitialized) {
2814 throw new Error("initializeWasm() must be awaited first!");
2816 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2817 return nativeResponseValue;
2820 export class LDKCOption_C2Tuple_u64u64ZZ {
2821 protected constructor() {}
2824 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2825 if(!isWasmInitialized) {
2826 throw new Error("initializeWasm() must be awaited first!");
2828 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2829 return nativeResponseValue;
2832 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2833 if(!isWasmInitialized) {
2834 throw new Error("initializeWasm() must be awaited first!");
2836 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2837 return nativeResponseValue;
2840 export interface LDKLogger {
2841 log (record: bigint): void;
2845 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2846 if(!isWasmInitialized) {
2847 throw new Error("initializeWasm() must be awaited first!");
2849 var new_obj_idx = js_objs.length;
2850 for (var i = 0; i < js_objs.length; i++) {
2851 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2853 js_objs[i] = new WeakRef(impl);
2854 return [wasm.TS_LDKLogger_new(i), i];
2856 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2858 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2859 if(!isWasmInitialized) {
2860 throw new Error("initializeWasm() must be awaited first!");
2862 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2863 return nativeResponseValue;
2865 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2867 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2868 if(!isWasmInitialized) {
2869 throw new Error("initializeWasm() must be awaited first!");
2871 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2872 return nativeResponseValue;
2874 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2876 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2877 if(!isWasmInitialized) {
2878 throw new Error("initializeWasm() must be awaited first!");
2880 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2881 return nativeResponseValue;
2883 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2885 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2886 if(!isWasmInitialized) {
2887 throw new Error("initializeWasm() must be awaited first!");
2889 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2890 return nativeResponseValue;
2892 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2894 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2895 if(!isWasmInitialized) {
2896 throw new Error("initializeWasm() must be awaited first!");
2898 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2899 return nativeResponseValue;
2901 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2903 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2904 if(!isWasmInitialized) {
2905 throw new Error("initializeWasm() must be awaited first!");
2907 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2908 return nativeResponseValue;
2910 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2912 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2913 if(!isWasmInitialized) {
2914 throw new Error("initializeWasm() must be awaited first!");
2916 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2917 return nativeResponseValue;
2919 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2921 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2922 if(!isWasmInitialized) {
2923 throw new Error("initializeWasm() must be awaited first!");
2925 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2926 return nativeResponseValue;
2928 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2930 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2931 if(!isWasmInitialized) {
2932 throw new Error("initializeWasm() must be awaited first!");
2934 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2935 return nativeResponseValue;
2937 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2939 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2940 if(!isWasmInitialized) {
2941 throw new Error("initializeWasm() must be awaited first!");
2943 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2944 return nativeResponseValue;
2946 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2948 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2949 if(!isWasmInitialized) {
2950 throw new Error("initializeWasm() must be awaited first!");
2952 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2953 return nativeResponseValue;
2955 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2957 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2958 if(!isWasmInitialized) {
2959 throw new Error("initializeWasm() must be awaited first!");
2961 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2962 return nativeResponseValue;
2964 // struct LDKOfferFeatures CResult_OfferFeaturesDecodeErrorZ_get_ok(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR owner);
2966 export function CResult_OfferFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2967 if(!isWasmInitialized) {
2968 throw new Error("initializeWasm() must be awaited first!");
2970 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_get_ok(owner);
2971 return nativeResponseValue;
2973 // struct LDKDecodeError CResult_OfferFeaturesDecodeErrorZ_get_err(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR owner);
2975 export function CResult_OfferFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2976 if(!isWasmInitialized) {
2977 throw new Error("initializeWasm() must be awaited first!");
2979 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_get_err(owner);
2980 return nativeResponseValue;
2982 // struct LDKInvoiceRequestFeatures CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR owner);
2984 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2985 if(!isWasmInitialized) {
2986 throw new Error("initializeWasm() must be awaited first!");
2988 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_ok(owner);
2989 return nativeResponseValue;
2991 // struct LDKDecodeError CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR owner);
2993 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2994 if(!isWasmInitialized) {
2995 throw new Error("initializeWasm() must be awaited first!");
2997 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_get_err(owner);
2998 return nativeResponseValue;
3000 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3002 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
3003 if(!isWasmInitialized) {
3004 throw new Error("initializeWasm() must be awaited first!");
3006 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
3007 return nativeResponseValue;
3009 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3011 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
3012 if(!isWasmInitialized) {
3013 throw new Error("initializeWasm() must be awaited first!");
3015 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
3016 return nativeResponseValue;
3018 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3020 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
3021 if(!isWasmInitialized) {
3022 throw new Error("initializeWasm() must be awaited first!");
3024 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
3025 return nativeResponseValue;
3027 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3029 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
3030 if(!isWasmInitialized) {
3031 throw new Error("initializeWasm() must be awaited first!");
3033 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
3034 return nativeResponseValue;
3037 export interface LDKAccess {
3038 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
3042 export function LDKAccess_new(impl: LDKAccess): [bigint, number] {
3043 if(!isWasmInitialized) {
3044 throw new Error("initializeWasm() must be awaited first!");
3046 var new_obj_idx = js_objs.length;
3047 for (var i = 0; i < js_objs.length; i++) {
3048 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3050 js_objs[i] = new WeakRef(impl);
3051 return [wasm.TS_LDKAccess_new(i), i];
3053 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
3055 export function Access_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
3056 if(!isWasmInitialized) {
3057 throw new Error("initializeWasm() must be awaited first!");
3059 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
3060 return nativeResponseValue;
3063 export class LDKCOption_AccessZ {
3064 protected constructor() {}
3067 export function LDKCOption_AccessZ_ty_from_ptr(ptr: bigint): number {
3068 if(!isWasmInitialized) {
3069 throw new Error("initializeWasm() must be awaited first!");
3071 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
3072 return nativeResponseValue;
3075 export function LDKCOption_AccessZ_Some_get_some(ptr: bigint): bigint {
3076 if(!isWasmInitialized) {
3077 throw new Error("initializeWasm() must be awaited first!");
3079 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
3080 return nativeResponseValue;
3082 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3084 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
3085 if(!isWasmInitialized) {
3086 throw new Error("initializeWasm() must be awaited first!");
3088 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
3089 return nativeResponseValue;
3091 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3093 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
3094 if(!isWasmInitialized) {
3095 throw new Error("initializeWasm() must be awaited first!");
3097 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
3098 return nativeResponseValue;
3100 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3102 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
3103 if(!isWasmInitialized) {
3104 throw new Error("initializeWasm() must be awaited first!");
3106 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
3107 return nativeResponseValue;
3109 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3111 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
3112 if(!isWasmInitialized) {
3113 throw new Error("initializeWasm() must be awaited first!");
3115 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
3116 return nativeResponseValue;
3118 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3120 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
3121 if(!isWasmInitialized) {
3122 throw new Error("initializeWasm() must be awaited first!");
3124 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
3125 return nativeResponseValue;
3128 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
3129 protected constructor() {}
3132 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
3133 if(!isWasmInitialized) {
3134 throw new Error("initializeWasm() must be awaited first!");
3136 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
3137 return nativeResponseValue;
3140 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3141 if(!isWasmInitialized) {
3142 throw new Error("initializeWasm() must be awaited first!");
3144 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3145 return nativeResponseValue;
3147 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3149 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
3150 if(!isWasmInitialized) {
3151 throw new Error("initializeWasm() must be awaited first!");
3153 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
3154 // debug statements here
3156 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3158 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
3159 if(!isWasmInitialized) {
3160 throw new Error("initializeWasm() must be awaited first!");
3162 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
3163 return nativeResponseValue;
3165 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3167 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3168 if(!isWasmInitialized) {
3169 throw new Error("initializeWasm() must be awaited first!");
3171 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
3172 return nativeResponseValue;
3174 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3176 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3177 if(!isWasmInitialized) {
3178 throw new Error("initializeWasm() must be awaited first!");
3180 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
3181 return nativeResponseValue;
3183 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3185 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3186 if(!isWasmInitialized) {
3187 throw new Error("initializeWasm() must be awaited first!");
3189 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
3190 return nativeResponseValue;
3192 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3194 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3195 if(!isWasmInitialized) {
3196 throw new Error("initializeWasm() must be awaited first!");
3198 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
3199 return nativeResponseValue;
3201 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3203 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
3204 if(!isWasmInitialized) {
3205 throw new Error("initializeWasm() must be awaited first!");
3207 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
3208 return nativeResponseValue;
3210 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3212 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
3213 if(!isWasmInitialized) {
3214 throw new Error("initializeWasm() must be awaited first!");
3216 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
3217 return nativeResponseValue;
3220 export class LDKNetAddress {
3221 protected constructor() {}
3224 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
3225 if(!isWasmInitialized) {
3226 throw new Error("initializeWasm() must be awaited first!");
3228 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
3229 return nativeResponseValue;
3232 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
3233 if(!isWasmInitialized) {
3234 throw new Error("initializeWasm() must be awaited first!");
3236 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
3237 return nativeResponseValue;
3240 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
3241 if(!isWasmInitialized) {
3242 throw new Error("initializeWasm() must be awaited first!");
3244 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3245 return nativeResponseValue;
3248 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
3249 if(!isWasmInitialized) {
3250 throw new Error("initializeWasm() must be awaited first!");
3252 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3253 return nativeResponseValue;
3256 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
3257 if(!isWasmInitialized) {
3258 throw new Error("initializeWasm() must be awaited first!");
3260 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3261 return nativeResponseValue;
3264 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3265 if(!isWasmInitialized) {
3266 throw new Error("initializeWasm() must be awaited first!");
3268 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3269 return nativeResponseValue;
3272 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3273 if(!isWasmInitialized) {
3274 throw new Error("initializeWasm() must be awaited first!");
3276 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3277 return nativeResponseValue;
3280 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
3281 if(!isWasmInitialized) {
3282 throw new Error("initializeWasm() must be awaited first!");
3284 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3285 return nativeResponseValue;
3288 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
3289 if(!isWasmInitialized) {
3290 throw new Error("initializeWasm() must be awaited first!");
3292 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3293 return nativeResponseValue;
3296 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
3297 if(!isWasmInitialized) {
3298 throw new Error("initializeWasm() must be awaited first!");
3300 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3301 return nativeResponseValue;
3304 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
3305 if(!isWasmInitialized) {
3306 throw new Error("initializeWasm() must be awaited first!");
3308 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
3309 return nativeResponseValue;
3312 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
3313 if(!isWasmInitialized) {
3314 throw new Error("initializeWasm() must be awaited first!");
3316 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
3317 return nativeResponseValue;
3319 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3321 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3322 if(!isWasmInitialized) {
3323 throw new Error("initializeWasm() must be awaited first!");
3325 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3326 return nativeResponseValue;
3328 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3330 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3331 if(!isWasmInitialized) {
3332 throw new Error("initializeWasm() must be awaited first!");
3334 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3335 return nativeResponseValue;
3337 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3339 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3340 if(!isWasmInitialized) {
3341 throw new Error("initializeWasm() must be awaited first!");
3343 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3344 return nativeResponseValue;
3346 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3348 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3349 if(!isWasmInitialized) {
3350 throw new Error("initializeWasm() must be awaited first!");
3352 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3353 return nativeResponseValue;
3355 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3357 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3358 if(!isWasmInitialized) {
3359 throw new Error("initializeWasm() must be awaited first!");
3361 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3362 return nativeResponseValue;
3364 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3366 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3367 if(!isWasmInitialized) {
3368 throw new Error("initializeWasm() must be awaited first!");
3370 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3371 return nativeResponseValue;
3373 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3375 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3376 if(!isWasmInitialized) {
3377 throw new Error("initializeWasm() must be awaited first!");
3379 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3380 return nativeResponseValue;
3382 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3384 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3385 if(!isWasmInitialized) {
3386 throw new Error("initializeWasm() must be awaited first!");
3388 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3389 return nativeResponseValue;
3392 export class LDKCOption_CVec_NetAddressZZ {
3393 protected constructor() {}
3396 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3401 return nativeResponseValue;
3404 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
3405 if(!isWasmInitialized) {
3406 throw new Error("initializeWasm() must be awaited first!");
3408 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3409 return nativeResponseValue;
3411 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3413 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3414 if(!isWasmInitialized) {
3415 throw new Error("initializeWasm() must be awaited first!");
3417 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3418 return nativeResponseValue;
3420 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3422 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3423 if(!isWasmInitialized) {
3424 throw new Error("initializeWasm() must be awaited first!");
3426 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3427 return nativeResponseValue;
3429 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3431 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3432 if(!isWasmInitialized) {
3433 throw new Error("initializeWasm() must be awaited first!");
3435 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3436 return nativeResponseValue;
3438 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3440 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3441 if(!isWasmInitialized) {
3442 throw new Error("initializeWasm() must be awaited first!");
3444 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3445 return nativeResponseValue;
3447 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3449 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3450 if(!isWasmInitialized) {
3451 throw new Error("initializeWasm() must be awaited first!");
3453 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3454 return nativeResponseValue;
3456 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3458 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3459 if(!isWasmInitialized) {
3460 throw new Error("initializeWasm() must be awaited first!");
3462 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3463 return nativeResponseValue;
3465 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3467 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
3468 if(!isWasmInitialized) {
3469 throw new Error("initializeWasm() must be awaited first!");
3471 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3472 return nativeResponseValue;
3474 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3476 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
3477 if(!isWasmInitialized) {
3478 throw new Error("initializeWasm() must be awaited first!");
3480 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3481 return nativeResponseValue;
3483 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3485 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
3486 if(!isWasmInitialized) {
3487 throw new Error("initializeWasm() must be awaited first!");
3489 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3490 return nativeResponseValue;
3492 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3494 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
3495 if(!isWasmInitialized) {
3496 throw new Error("initializeWasm() must be awaited first!");
3498 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3499 // debug statements here
3501 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3503 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
3504 if(!isWasmInitialized) {
3505 throw new Error("initializeWasm() must be awaited first!");
3507 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3508 return nativeResponseValue;
3510 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3512 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
3513 if(!isWasmInitialized) {
3514 throw new Error("initializeWasm() must be awaited first!");
3516 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3517 // debug statements here
3519 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3521 export function C2Tuple_SignatureSignatureZ_get_a(owner: bigint): number {
3522 if(!isWasmInitialized) {
3523 throw new Error("initializeWasm() must be awaited first!");
3525 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3526 return nativeResponseValue;
3528 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3530 export function C2Tuple_SignatureSignatureZ_get_b(owner: bigint): number {
3531 if(!isWasmInitialized) {
3532 throw new Error("initializeWasm() must be awaited first!");
3534 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3535 return nativeResponseValue;
3537 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3539 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: bigint): bigint {
3540 if(!isWasmInitialized) {
3541 throw new Error("initializeWasm() must be awaited first!");
3543 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3544 return nativeResponseValue;
3546 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3548 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: bigint): void {
3549 if(!isWasmInitialized) {
3550 throw new Error("initializeWasm() must be awaited first!");
3552 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3553 // debug statements here
3555 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3557 export function CResult_SecretKeyNoneZ_get_ok(owner: bigint): number {
3558 if(!isWasmInitialized) {
3559 throw new Error("initializeWasm() must be awaited first!");
3561 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3562 return nativeResponseValue;
3564 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3566 export function CResult_SecretKeyNoneZ_get_err(owner: bigint): void {
3567 if(!isWasmInitialized) {
3568 throw new Error("initializeWasm() must be awaited first!");
3570 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3571 // debug statements here
3573 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3575 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
3576 if(!isWasmInitialized) {
3577 throw new Error("initializeWasm() must be awaited first!");
3579 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
3580 return nativeResponseValue;
3582 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
3584 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
3585 if(!isWasmInitialized) {
3586 throw new Error("initializeWasm() must be awaited first!");
3588 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
3589 // debug statements here
3592 export class LDKCOption_ScalarZ {
3593 protected constructor() {}
3596 export function LDKCOption_ScalarZ_ty_from_ptr(ptr: bigint): number {
3597 if(!isWasmInitialized) {
3598 throw new Error("initializeWasm() must be awaited first!");
3600 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_ty_from_ptr(ptr);
3601 return nativeResponseValue;
3604 export function LDKCOption_ScalarZ_Some_get_some(ptr: bigint): bigint {
3605 if(!isWasmInitialized) {
3606 throw new Error("initializeWasm() must be awaited first!");
3608 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_Some_get_some(ptr);
3609 return nativeResponseValue;
3611 // struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3613 export function CResult_SharedSecretNoneZ_get_ok(owner: bigint): number {
3614 if(!isWasmInitialized) {
3615 throw new Error("initializeWasm() must be awaited first!");
3617 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_ok(owner);
3618 return nativeResponseValue;
3620 // void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
3622 export function CResult_SharedSecretNoneZ_get_err(owner: bigint): void {
3623 if(!isWasmInitialized) {
3624 throw new Error("initializeWasm() must be awaited first!");
3626 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_err(owner);
3627 // debug statements here
3630 export interface LDKBaseSign {
3631 get_per_commitment_point (idx: bigint): number;
3632 release_commitment_secret (idx: bigint): number;
3633 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
3634 channel_keys_id (): number;
3635 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
3636 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
3637 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
3638 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
3639 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
3640 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
3641 sign_closing_transaction (closing_tx: bigint): bigint;
3642 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
3643 sign_channel_announcement (msg: bigint): bigint;
3644 provide_channel_parameters (channel_parameters: bigint): void;
3648 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: bigint): [bigint, number] {
3649 if(!isWasmInitialized) {
3650 throw new Error("initializeWasm() must be awaited first!");
3652 var new_obj_idx = js_objs.length;
3653 for (var i = 0; i < js_objs.length; i++) {
3654 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3656 js_objs[i] = new WeakRef(impl);
3657 return [wasm.TS_LDKBaseSign_new(i, pubkeys), i];
3659 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3661 export function BaseSign_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
3662 if(!isWasmInitialized) {
3663 throw new Error("initializeWasm() must be awaited first!");
3665 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3666 return nativeResponseValue;
3668 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3670 export function BaseSign_release_commitment_secret(this_arg: bigint, idx: bigint): number {
3671 if(!isWasmInitialized) {
3672 throw new Error("initializeWasm() must be awaited first!");
3674 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3675 return nativeResponseValue;
3677 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3679 export function BaseSign_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
3680 if(!isWasmInitialized) {
3681 throw new Error("initializeWasm() must be awaited first!");
3683 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3684 return nativeResponseValue;
3686 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3688 export function BaseSign_channel_keys_id(this_arg: bigint): number {
3689 if(!isWasmInitialized) {
3690 throw new Error("initializeWasm() must be awaited first!");
3692 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3693 return nativeResponseValue;
3695 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3697 export function BaseSign_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
3698 if(!isWasmInitialized) {
3699 throw new Error("initializeWasm() must be awaited first!");
3701 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3702 return nativeResponseValue;
3704 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3706 export function BaseSign_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
3707 if(!isWasmInitialized) {
3708 throw new Error("initializeWasm() must be awaited first!");
3710 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3711 return nativeResponseValue;
3713 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3715 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
3716 if(!isWasmInitialized) {
3717 throw new Error("initializeWasm() must be awaited first!");
3719 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3720 return nativeResponseValue;
3722 // 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]
3724 export function BaseSign_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
3725 if(!isWasmInitialized) {
3726 throw new Error("initializeWasm() must be awaited first!");
3728 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3729 return nativeResponseValue;
3731 // 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
3733 export function BaseSign_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
3734 if(!isWasmInitialized) {
3735 throw new Error("initializeWasm() must be awaited first!");
3737 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3738 return nativeResponseValue;
3740 // 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
3742 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
3743 if(!isWasmInitialized) {
3744 throw new Error("initializeWasm() must be awaited first!");
3746 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3747 return nativeResponseValue;
3749 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3751 export function BaseSign_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
3752 if(!isWasmInitialized) {
3753 throw new Error("initializeWasm() must be awaited first!");
3755 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3756 return nativeResponseValue;
3758 // LDKCResult_SignatureNoneZ BaseSign_sign_holder_anchor_input LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
3760 export function BaseSign_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
3761 if(!isWasmInitialized) {
3762 throw new Error("initializeWasm() must be awaited first!");
3764 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_anchor_input(this_arg, anchor_tx, input);
3765 return nativeResponseValue;
3767 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3769 export function BaseSign_sign_channel_announcement(this_arg: bigint, msg: bigint): bigint {
3770 if(!isWasmInitialized) {
3771 throw new Error("initializeWasm() must be awaited first!");
3773 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3774 return nativeResponseValue;
3776 // void BaseSign_provide_channel_parameters LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3778 export function BaseSign_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
3779 if(!isWasmInitialized) {
3780 throw new Error("initializeWasm() must be awaited first!");
3782 const nativeResponseValue = wasm.TS_BaseSign_provide_channel_parameters(this_arg, channel_parameters);
3783 // debug statements here
3785 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3787 export function BaseSign_get_pubkeys(this_arg: bigint): bigint {
3788 if(!isWasmInitialized) {
3789 throw new Error("initializeWasm() must be awaited first!");
3791 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3792 return nativeResponseValue;
3795 export interface LDKSign {
3800 export function LDKSign_new(impl: LDKSign, BaseSign: number, pubkeys: bigint): [bigint, number] {
3801 if(!isWasmInitialized) {
3802 throw new Error("initializeWasm() must be awaited first!");
3804 var new_obj_idx = js_objs.length;
3805 for (var i = 0; i < js_objs.length; i++) {
3806 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3808 js_objs[i] = new WeakRef(impl);
3809 return [wasm.TS_LDKSign_new(i, BaseSign, pubkeys), i];
3811 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3813 export function Sign_write(this_arg: bigint): number {
3814 if(!isWasmInitialized) {
3815 throw new Error("initializeWasm() must be awaited first!");
3817 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3818 return nativeResponseValue;
3820 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3822 export function CResult_SignDecodeErrorZ_get_ok(owner: bigint): bigint {
3823 if(!isWasmInitialized) {
3824 throw new Error("initializeWasm() must be awaited first!");
3826 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3827 return nativeResponseValue;
3829 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3831 export function CResult_SignDecodeErrorZ_get_err(owner: bigint): bigint {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3836 return nativeResponseValue;
3838 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3840 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
3841 if(!isWasmInitialized) {
3842 throw new Error("initializeWasm() must be awaited first!");
3844 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3845 return nativeResponseValue;
3847 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3849 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
3850 if(!isWasmInitialized) {
3851 throw new Error("initializeWasm() must be awaited first!");
3853 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3854 // debug statements here
3856 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3858 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
3859 if(!isWasmInitialized) {
3860 throw new Error("initializeWasm() must be awaited first!");
3862 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3863 return nativeResponseValue;
3865 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3867 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
3868 if(!isWasmInitialized) {
3869 throw new Error("initializeWasm() must be awaited first!");
3871 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3872 // debug statements here
3874 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3876 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
3877 if(!isWasmInitialized) {
3878 throw new Error("initializeWasm() must be awaited first!");
3880 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3881 return nativeResponseValue;
3883 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3885 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
3886 if(!isWasmInitialized) {
3887 throw new Error("initializeWasm() must be awaited first!");
3889 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3890 return nativeResponseValue;
3892 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3894 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
3895 if(!isWasmInitialized) {
3896 throw new Error("initializeWasm() must be awaited first!");
3898 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3899 return nativeResponseValue;
3901 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3903 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
3904 if(!isWasmInitialized) {
3905 throw new Error("initializeWasm() must be awaited first!");
3907 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3908 // debug statements here
3911 export class LDKCOption_u16Z {
3912 protected constructor() {}
3915 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
3916 if(!isWasmInitialized) {
3917 throw new Error("initializeWasm() must be awaited first!");
3919 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3920 return nativeResponseValue;
3923 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
3924 if(!isWasmInitialized) {
3925 throw new Error("initializeWasm() must be awaited first!");
3927 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3928 return nativeResponseValue;
3931 export class LDKAPIError {
3932 protected constructor() {}
3935 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
3936 if(!isWasmInitialized) {
3937 throw new Error("initializeWasm() must be awaited first!");
3939 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3940 return nativeResponseValue;
3943 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
3944 if(!isWasmInitialized) {
3945 throw new Error("initializeWasm() must be awaited first!");
3947 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3948 return nativeResponseValue;
3951 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
3952 if(!isWasmInitialized) {
3953 throw new Error("initializeWasm() must be awaited first!");
3955 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3956 return nativeResponseValue;
3959 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
3960 if(!isWasmInitialized) {
3961 throw new Error("initializeWasm() must be awaited first!");
3963 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3964 return nativeResponseValue;
3967 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
3968 if(!isWasmInitialized) {
3969 throw new Error("initializeWasm() must be awaited first!");
3971 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
3972 return nativeResponseValue;
3975 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
3976 if(!isWasmInitialized) {
3977 throw new Error("initializeWasm() must be awaited first!");
3979 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3980 return nativeResponseValue;
3983 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
3984 if(!isWasmInitialized) {
3985 throw new Error("initializeWasm() must be awaited first!");
3987 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3988 return nativeResponseValue;
3990 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3992 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
3993 if(!isWasmInitialized) {
3994 throw new Error("initializeWasm() must be awaited first!");
3996 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3997 // debug statements here
3999 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
4001 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
4002 if(!isWasmInitialized) {
4003 throw new Error("initializeWasm() must be awaited first!");
4005 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
4006 return nativeResponseValue;
4008 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
4010 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
4011 if(!isWasmInitialized) {
4012 throw new Error("initializeWasm() must be awaited first!");
4014 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
4015 return nativeResponseValue;
4017 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
4019 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
4024 return nativeResponseValue;
4027 export class LDKPaymentSendFailure {
4028 protected constructor() {}
4031 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4032 if(!isWasmInitialized) {
4033 throw new Error("initializeWasm() must be awaited first!");
4035 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4036 return nativeResponseValue;
4039 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4040 if(!isWasmInitialized) {
4041 throw new Error("initializeWasm() must be awaited first!");
4043 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4044 return nativeResponseValue;
4047 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4052 return nativeResponseValue;
4055 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4060 return nativeResponseValue;
4063 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4064 if(!isWasmInitialized) {
4065 throw new Error("initializeWasm() must be awaited first!");
4067 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4068 return nativeResponseValue;
4071 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4072 if(!isWasmInitialized) {
4073 throw new Error("initializeWasm() must be awaited first!");
4075 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4076 return nativeResponseValue;
4079 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4080 if(!isWasmInitialized) {
4081 throw new Error("initializeWasm() must be awaited first!");
4083 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4084 return nativeResponseValue;
4086 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4088 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4089 if(!isWasmInitialized) {
4090 throw new Error("initializeWasm() must be awaited first!");
4092 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4093 // debug statements here
4095 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4097 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4098 if(!isWasmInitialized) {
4099 throw new Error("initializeWasm() must be awaited first!");
4101 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4102 return nativeResponseValue;
4104 // struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
4106 export function CResult_PaymentHashPaymentSendFailureZ_get_ok(owner: bigint): number {
4107 if(!isWasmInitialized) {
4108 throw new Error("initializeWasm() must be awaited first!");
4110 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(owner);
4111 return nativeResponseValue;
4113 // struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
4115 export function CResult_PaymentHashPaymentSendFailureZ_get_err(owner: bigint): bigint {
4116 if(!isWasmInitialized) {
4117 throw new Error("initializeWasm() must be awaited first!");
4119 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_err(owner);
4120 return nativeResponseValue;
4122 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4124 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
4125 if(!isWasmInitialized) {
4126 throw new Error("initializeWasm() must be awaited first!");
4128 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
4129 return nativeResponseValue;
4131 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4133 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
4134 if(!isWasmInitialized) {
4135 throw new Error("initializeWasm() must be awaited first!");
4137 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
4138 return nativeResponseValue;
4140 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4142 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4143 if(!isWasmInitialized) {
4144 throw new Error("initializeWasm() must be awaited first!");
4146 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
4147 return nativeResponseValue;
4149 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4151 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4152 if(!isWasmInitialized) {
4153 throw new Error("initializeWasm() must be awaited first!");
4155 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
4156 return nativeResponseValue;
4158 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4160 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
4161 if(!isWasmInitialized) {
4162 throw new Error("initializeWasm() must be awaited first!");
4164 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
4165 return nativeResponseValue;
4167 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4169 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
4170 if(!isWasmInitialized) {
4171 throw new Error("initializeWasm() must be awaited first!");
4173 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
4174 return nativeResponseValue;
4176 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4178 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
4179 if(!isWasmInitialized) {
4180 throw new Error("initializeWasm() must be awaited first!");
4182 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
4183 return nativeResponseValue;
4185 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4187 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
4188 if(!isWasmInitialized) {
4189 throw new Error("initializeWasm() must be awaited first!");
4191 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
4192 // debug statements here
4194 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4196 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: bigint): bigint {
4197 if(!isWasmInitialized) {
4198 throw new Error("initializeWasm() must be awaited first!");
4200 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
4201 return nativeResponseValue;
4203 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4205 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: bigint): bigint {
4206 if(!isWasmInitialized) {
4207 throw new Error("initializeWasm() must be awaited first!");
4209 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
4210 return nativeResponseValue;
4212 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4214 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
4215 if(!isWasmInitialized) {
4216 throw new Error("initializeWasm() must be awaited first!");
4218 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
4219 return nativeResponseValue;
4221 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4223 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
4224 if(!isWasmInitialized) {
4225 throw new Error("initializeWasm() must be awaited first!");
4227 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
4228 // debug statements here
4230 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4232 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: bigint): number {
4233 if(!isWasmInitialized) {
4234 throw new Error("initializeWasm() must be awaited first!");
4236 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
4237 return nativeResponseValue;
4239 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4241 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: bigint): bigint {
4242 if(!isWasmInitialized) {
4243 throw new Error("initializeWasm() must be awaited first!");
4245 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
4246 return nativeResponseValue;
4248 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4250 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
4255 return nativeResponseValue;
4257 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4259 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
4260 if(!isWasmInitialized) {
4261 throw new Error("initializeWasm() must be awaited first!");
4263 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
4264 return nativeResponseValue;
4266 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4268 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4269 if(!isWasmInitialized) {
4270 throw new Error("initializeWasm() must be awaited first!");
4272 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4273 return nativeResponseValue;
4275 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4277 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4278 if(!isWasmInitialized) {
4279 throw new Error("initializeWasm() must be awaited first!");
4281 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4282 return nativeResponseValue;
4284 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4286 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4287 if(!isWasmInitialized) {
4288 throw new Error("initializeWasm() must be awaited first!");
4290 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4291 return nativeResponseValue;
4293 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4295 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4296 if(!isWasmInitialized) {
4297 throw new Error("initializeWasm() must be awaited first!");
4299 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4300 return nativeResponseValue;
4302 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4304 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4305 if(!isWasmInitialized) {
4306 throw new Error("initializeWasm() must be awaited first!");
4308 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4309 return nativeResponseValue;
4311 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4313 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4314 if(!isWasmInitialized) {
4315 throw new Error("initializeWasm() must be awaited first!");
4317 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4318 return nativeResponseValue;
4320 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4322 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4323 if(!isWasmInitialized) {
4324 throw new Error("initializeWasm() must be awaited first!");
4326 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4327 return nativeResponseValue;
4329 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4331 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4332 if(!isWasmInitialized) {
4333 throw new Error("initializeWasm() must be awaited first!");
4335 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4336 return nativeResponseValue;
4339 export interface LDKWatch {
4340 watch_channel (funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus;
4341 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4342 release_pending_monitor_events (): number;
4346 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4347 if(!isWasmInitialized) {
4348 throw new Error("initializeWasm() must be awaited first!");
4350 var new_obj_idx = js_objs.length;
4351 for (var i = 0; i < js_objs.length; i++) {
4352 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4354 js_objs[i] = new WeakRef(impl);
4355 return [wasm.TS_LDKWatch_new(i), i];
4357 // LDKChannelMonitorUpdateStatus Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4359 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus {
4360 if(!isWasmInitialized) {
4361 throw new Error("initializeWasm() must be awaited first!");
4363 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4364 return nativeResponseValue;
4366 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
4368 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4369 if(!isWasmInitialized) {
4370 throw new Error("initializeWasm() must be awaited first!");
4372 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4373 return nativeResponseValue;
4375 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4377 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4378 if(!isWasmInitialized) {
4379 throw new Error("initializeWasm() must be awaited first!");
4381 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4382 return nativeResponseValue;
4385 export interface LDKBroadcasterInterface {
4386 broadcast_transaction (tx: number): void;
4390 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 var new_obj_idx = js_objs.length;
4395 for (var i = 0; i < js_objs.length; i++) {
4396 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4398 js_objs[i] = new WeakRef(impl);
4399 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4401 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4403 export function BroadcasterInterface_broadcast_transaction(this_arg: bigint, tx: number): void {
4404 if(!isWasmInitialized) {
4405 throw new Error("initializeWasm() must be awaited first!");
4407 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4408 // debug statements here
4411 export interface LDKKeysInterface {
4412 get_node_secret (recipient: Recipient): bigint;
4413 get_node_id (recipient: Recipient): bigint;
4414 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4415 get_destination_script (): number;
4416 get_shutdown_scriptpubkey (): bigint;
4417 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
4418 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
4419 get_secure_random_bytes (): number;
4420 read_chan_signer (reader: number): bigint;
4421 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint;
4422 get_inbound_payment_key_material (): number;
4426 export function LDKKeysInterface_new(impl: LDKKeysInterface): [bigint, number] {
4427 if(!isWasmInitialized) {
4428 throw new Error("initializeWasm() must be awaited first!");
4430 var new_obj_idx = js_objs.length;
4431 for (var i = 0; i < js_objs.length; i++) {
4432 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4434 js_objs[i] = new WeakRef(impl);
4435 return [wasm.TS_LDKKeysInterface_new(i), i];
4437 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4439 export function KeysInterface_get_node_secret(this_arg: bigint, recipient: Recipient): bigint {
4440 if(!isWasmInitialized) {
4441 throw new Error("initializeWasm() must be awaited first!");
4443 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4444 return nativeResponseValue;
4446 // LDKCResult_PublicKeyNoneZ KeysInterface_get_node_id LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4448 export function KeysInterface_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
4449 if(!isWasmInitialized) {
4450 throw new Error("initializeWasm() must be awaited first!");
4452 const nativeResponseValue = wasm.TS_KeysInterface_get_node_id(this_arg, recipient);
4453 return nativeResponseValue;
4455 // LDKCResult_SharedSecretNoneZ KeysInterface_ecdh LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak
4457 export function KeysInterface_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4458 if(!isWasmInitialized) {
4459 throw new Error("initializeWasm() must be awaited first!");
4461 const nativeResponseValue = wasm.TS_KeysInterface_ecdh(this_arg, recipient, other_key, tweak);
4462 return nativeResponseValue;
4464 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4466 export function KeysInterface_get_destination_script(this_arg: bigint): number {
4467 if(!isWasmInitialized) {
4468 throw new Error("initializeWasm() must be awaited first!");
4470 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4471 return nativeResponseValue;
4473 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4475 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4476 if(!isWasmInitialized) {
4477 throw new Error("initializeWasm() must be awaited first!");
4479 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4480 return nativeResponseValue;
4482 // LDKThirtyTwoBytes KeysInterface_generate_channel_keys_id LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
4484 export function KeysInterface_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
4485 if(!isWasmInitialized) {
4486 throw new Error("initializeWasm() must be awaited first!");
4488 const nativeResponseValue = wasm.TS_KeysInterface_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
4489 return nativeResponseValue;
4491 // LDKSign KeysInterface_derive_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
4493 export function KeysInterface_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
4494 if(!isWasmInitialized) {
4495 throw new Error("initializeWasm() must be awaited first!");
4497 const nativeResponseValue = wasm.TS_KeysInterface_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
4498 return nativeResponseValue;
4500 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4502 export function KeysInterface_get_secure_random_bytes(this_arg: bigint): number {
4503 if(!isWasmInitialized) {
4504 throw new Error("initializeWasm() must be awaited first!");
4506 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4507 return nativeResponseValue;
4509 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4511 export function KeysInterface_read_chan_signer(this_arg: bigint, reader: number): bigint {
4512 if(!isWasmInitialized) {
4513 throw new Error("initializeWasm() must be awaited first!");
4515 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4516 return nativeResponseValue;
4518 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient receipient
4520 export function KeysInterface_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint {
4521 if(!isWasmInitialized) {
4522 throw new Error("initializeWasm() must be awaited first!");
4524 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4525 return nativeResponseValue;
4527 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4529 export function KeysInterface_get_inbound_payment_key_material(this_arg: bigint): number {
4530 if(!isWasmInitialized) {
4531 throw new Error("initializeWasm() must be awaited first!");
4533 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4534 return nativeResponseValue;
4537 export interface LDKFeeEstimator {
4538 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4542 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4543 if(!isWasmInitialized) {
4544 throw new Error("initializeWasm() must be awaited first!");
4546 var new_obj_idx = js_objs.length;
4547 for (var i = 0; i < js_objs.length; i++) {
4548 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4550 js_objs[i] = new WeakRef(impl);
4551 return [wasm.TS_LDKFeeEstimator_new(i), i];
4553 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4555 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4556 if(!isWasmInitialized) {
4557 throw new Error("initializeWasm() must be awaited first!");
4559 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4560 return nativeResponseValue;
4562 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4564 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
4565 if(!isWasmInitialized) {
4566 throw new Error("initializeWasm() must be awaited first!");
4568 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4569 return nativeResponseValue;
4571 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4573 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
4574 if(!isWasmInitialized) {
4575 throw new Error("initializeWasm() must be awaited first!");
4577 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4578 return nativeResponseValue;
4580 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4582 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4583 if(!isWasmInitialized) {
4584 throw new Error("initializeWasm() must be awaited first!");
4586 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4587 return nativeResponseValue;
4589 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4591 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4592 if(!isWasmInitialized) {
4593 throw new Error("initializeWasm() must be awaited first!");
4595 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4596 return nativeResponseValue;
4598 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4600 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4601 if(!isWasmInitialized) {
4602 throw new Error("initializeWasm() must be awaited first!");
4604 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4605 return nativeResponseValue;
4607 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4609 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4610 if(!isWasmInitialized) {
4611 throw new Error("initializeWasm() must be awaited first!");
4613 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4614 return nativeResponseValue;
4616 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4618 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
4619 if(!isWasmInitialized) {
4620 throw new Error("initializeWasm() must be awaited first!");
4622 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4623 return nativeResponseValue;
4625 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4627 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
4628 if(!isWasmInitialized) {
4629 throw new Error("initializeWasm() must be awaited first!");
4631 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4632 return nativeResponseValue;
4635 export interface LDKType {
4637 debug_str (): number;
4642 export function LDKType_new(impl: LDKType): [bigint, number] {
4643 if(!isWasmInitialized) {
4644 throw new Error("initializeWasm() must be awaited first!");
4646 var new_obj_idx = js_objs.length;
4647 for (var i = 0; i < js_objs.length; i++) {
4648 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4650 js_objs[i] = new WeakRef(impl);
4651 return [wasm.TS_LDKType_new(i), i];
4653 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4655 export function Type_type_id(this_arg: bigint): number {
4656 if(!isWasmInitialized) {
4657 throw new Error("initializeWasm() must be awaited first!");
4659 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4660 return nativeResponseValue;
4662 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4664 export function Type_debug_str(this_arg: bigint): number {
4665 if(!isWasmInitialized) {
4666 throw new Error("initializeWasm() must be awaited first!");
4668 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4669 return nativeResponseValue;
4671 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4673 export function Type_write(this_arg: bigint): number {
4674 if(!isWasmInitialized) {
4675 throw new Error("initializeWasm() must be awaited first!");
4677 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4678 return nativeResponseValue;
4681 export class LDKCOption_TypeZ {
4682 protected constructor() {}
4685 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
4686 if(!isWasmInitialized) {
4687 throw new Error("initializeWasm() must be awaited first!");
4689 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4690 return nativeResponseValue;
4693 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
4694 if(!isWasmInitialized) {
4695 throw new Error("initializeWasm() must be awaited first!");
4697 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4698 return nativeResponseValue;
4700 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4702 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
4703 if(!isWasmInitialized) {
4704 throw new Error("initializeWasm() must be awaited first!");
4706 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4707 return nativeResponseValue;
4709 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4711 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
4712 if(!isWasmInitialized) {
4713 throw new Error("initializeWasm() must be awaited first!");
4715 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4716 return nativeResponseValue;
4719 export class LDKPaymentError {
4720 protected constructor() {}
4723 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
4724 if(!isWasmInitialized) {
4725 throw new Error("initializeWasm() must be awaited first!");
4727 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4728 return nativeResponseValue;
4731 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
4732 if(!isWasmInitialized) {
4733 throw new Error("initializeWasm() must be awaited first!");
4735 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4736 return nativeResponseValue;
4739 export function LDKPaymentError_Routing_get_routing(ptr: bigint): bigint {
4740 if(!isWasmInitialized) {
4741 throw new Error("initializeWasm() must be awaited first!");
4743 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4744 return nativeResponseValue;
4747 export function LDKPaymentError_Sending_get_sending(ptr: bigint): bigint {
4748 if(!isWasmInitialized) {
4749 throw new Error("initializeWasm() must be awaited first!");
4751 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4752 return nativeResponseValue;
4754 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4756 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
4757 if(!isWasmInitialized) {
4758 throw new Error("initializeWasm() must be awaited first!");
4760 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4761 return nativeResponseValue;
4763 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4765 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
4766 if(!isWasmInitialized) {
4767 throw new Error("initializeWasm() must be awaited first!");
4769 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4770 return nativeResponseValue;
4772 // void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
4774 export function CResult_NonePaymentErrorZ_get_ok(owner: bigint): void {
4775 if(!isWasmInitialized) {
4776 throw new Error("initializeWasm() must be awaited first!");
4778 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_ok(owner);
4779 // debug statements here
4781 // struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
4783 export function CResult_NonePaymentErrorZ_get_err(owner: bigint): bigint {
4784 if(!isWasmInitialized) {
4785 throw new Error("initializeWasm() must be awaited first!");
4787 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_err(owner);
4788 return nativeResponseValue;
4790 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4792 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
4793 if(!isWasmInitialized) {
4794 throw new Error("initializeWasm() must be awaited first!");
4796 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4797 return nativeResponseValue;
4799 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4801 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
4802 if(!isWasmInitialized) {
4803 throw new Error("initializeWasm() must be awaited first!");
4805 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4806 return nativeResponseValue;
4808 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
4810 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
4811 if(!isWasmInitialized) {
4812 throw new Error("initializeWasm() must be awaited first!");
4814 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
4815 return nativeResponseValue;
4817 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
4819 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
4820 if(!isWasmInitialized) {
4821 throw new Error("initializeWasm() must be awaited first!");
4823 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
4824 return nativeResponseValue;
4826 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4828 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4829 if(!isWasmInitialized) {
4830 throw new Error("initializeWasm() must be awaited first!");
4832 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4833 return nativeResponseValue;
4835 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4837 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4838 if(!isWasmInitialized) {
4839 throw new Error("initializeWasm() must be awaited first!");
4841 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4842 return nativeResponseValue;
4845 export class LDKCOption_MonitorEventZ {
4846 protected constructor() {}
4849 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
4850 if(!isWasmInitialized) {
4851 throw new Error("initializeWasm() must be awaited first!");
4853 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4854 return nativeResponseValue;
4857 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
4858 if(!isWasmInitialized) {
4859 throw new Error("initializeWasm() must be awaited first!");
4861 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4862 return nativeResponseValue;
4864 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4866 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4867 if(!isWasmInitialized) {
4868 throw new Error("initializeWasm() must be awaited first!");
4870 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4871 return nativeResponseValue;
4873 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4875 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
4876 if(!isWasmInitialized) {
4877 throw new Error("initializeWasm() must be awaited first!");
4879 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4880 return nativeResponseValue;
4882 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4884 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4885 if(!isWasmInitialized) {
4886 throw new Error("initializeWasm() must be awaited first!");
4888 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4889 return nativeResponseValue;
4891 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4893 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4894 if(!isWasmInitialized) {
4895 throw new Error("initializeWasm() must be awaited first!");
4897 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4898 return nativeResponseValue;
4900 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4902 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
4903 if(!isWasmInitialized) {
4904 throw new Error("initializeWasm() must be awaited first!");
4906 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4907 return nativeResponseValue;
4909 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4911 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
4912 if(!isWasmInitialized) {
4913 throw new Error("initializeWasm() must be awaited first!");
4915 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4916 return nativeResponseValue;
4918 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4920 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
4921 if(!isWasmInitialized) {
4922 throw new Error("initializeWasm() must be awaited first!");
4924 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4925 return nativeResponseValue;
4927 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4929 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
4930 if(!isWasmInitialized) {
4931 throw new Error("initializeWasm() must be awaited first!");
4933 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4934 return nativeResponseValue;
4936 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4938 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
4939 if(!isWasmInitialized) {
4940 throw new Error("initializeWasm() must be awaited first!");
4942 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4943 return nativeResponseValue;
4945 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4947 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
4948 if(!isWasmInitialized) {
4949 throw new Error("initializeWasm() must be awaited first!");
4951 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4952 return nativeResponseValue;
4954 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4956 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
4957 if(!isWasmInitialized) {
4958 throw new Error("initializeWasm() must be awaited first!");
4960 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4961 return nativeResponseValue;
4963 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4965 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
4966 if(!isWasmInitialized) {
4967 throw new Error("initializeWasm() must be awaited first!");
4969 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4970 return nativeResponseValue;
4972 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4974 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
4975 if(!isWasmInitialized) {
4976 throw new Error("initializeWasm() must be awaited first!");
4978 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4979 return nativeResponseValue;
4981 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4983 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
4984 if(!isWasmInitialized) {
4985 throw new Error("initializeWasm() must be awaited first!");
4987 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4988 return nativeResponseValue;
4991 export class LDKBalance {
4992 protected constructor() {}
4995 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
4996 if(!isWasmInitialized) {
4997 throw new Error("initializeWasm() must be awaited first!");
4999 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5000 return nativeResponseValue;
5003 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: bigint): bigint {
5004 if(!isWasmInitialized) {
5005 throw new Error("initializeWasm() must be awaited first!");
5007 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
5008 return nativeResponseValue;
5011 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: bigint): bigint {
5012 if(!isWasmInitialized) {
5013 throw new Error("initializeWasm() must be awaited first!");
5015 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
5016 return nativeResponseValue;
5019 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5020 if(!isWasmInitialized) {
5021 throw new Error("initializeWasm() must be awaited first!");
5023 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5024 return nativeResponseValue;
5027 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5028 if(!isWasmInitialized) {
5029 throw new Error("initializeWasm() must be awaited first!");
5031 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
5032 return nativeResponseValue;
5035 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5036 if(!isWasmInitialized) {
5037 throw new Error("initializeWasm() must be awaited first!");
5039 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5040 return nativeResponseValue;
5043 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5044 if(!isWasmInitialized) {
5045 throw new Error("initializeWasm() must be awaited first!");
5047 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(ptr);
5048 return nativeResponseValue;
5051 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5056 return nativeResponseValue;
5059 export function LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr: bigint): bigint {
5060 if(!isWasmInitialized) {
5061 throw new Error("initializeWasm() must be awaited first!");
5063 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(ptr);
5064 return nativeResponseValue;
5067 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5068 if(!isWasmInitialized) {
5069 throw new Error("initializeWasm() must be awaited first!");
5071 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5072 return nativeResponseValue;
5075 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
5076 if(!isWasmInitialized) {
5077 throw new Error("initializeWasm() must be awaited first!");
5079 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(ptr);
5080 return nativeResponseValue;
5082 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5084 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
5085 if(!isWasmInitialized) {
5086 throw new Error("initializeWasm() must be awaited first!");
5088 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
5089 return nativeResponseValue;
5091 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
5093 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
5094 if(!isWasmInitialized) {
5095 throw new Error("initializeWasm() must be awaited first!");
5097 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
5098 return nativeResponseValue;
5100 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5102 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5103 if(!isWasmInitialized) {
5104 throw new Error("initializeWasm() must be awaited first!");
5106 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
5107 return nativeResponseValue;
5109 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5111 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5112 if(!isWasmInitialized) {
5113 throw new Error("initializeWasm() must be awaited first!");
5115 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
5116 return nativeResponseValue;
5118 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5120 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5121 if(!isWasmInitialized) {
5122 throw new Error("initializeWasm() must be awaited first!");
5124 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5125 return nativeResponseValue;
5127 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5129 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5130 if(!isWasmInitialized) {
5131 throw new Error("initializeWasm() must be awaited first!");
5133 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5134 return nativeResponseValue;
5137 export interface LDKCustomOnionMessageContents {
5138 tlv_type (): bigint;
5143 export function LDKCustomOnionMessageContents_new(impl: LDKCustomOnionMessageContents): [bigint, number] {
5144 if(!isWasmInitialized) {
5145 throw new Error("initializeWasm() must be awaited first!");
5147 var new_obj_idx = js_objs.length;
5148 for (var i = 0; i < js_objs.length; i++) {
5149 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5151 js_objs[i] = new WeakRef(impl);
5152 return [wasm.TS_LDKCustomOnionMessageContents_new(i), i];
5154 // uint64_t CustomOnionMessageContents_tlv_type LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5156 export function CustomOnionMessageContents_tlv_type(this_arg: bigint): bigint {
5157 if(!isWasmInitialized) {
5158 throw new Error("initializeWasm() must be awaited first!");
5160 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_tlv_type(this_arg);
5161 return nativeResponseValue;
5163 // LDKCVec_u8Z CustomOnionMessageContents_write LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5165 export function CustomOnionMessageContents_write(this_arg: bigint): number {
5166 if(!isWasmInitialized) {
5167 throw new Error("initializeWasm() must be awaited first!");
5169 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_write(this_arg);
5170 return nativeResponseValue;
5173 export class LDKCOption_CustomOnionMessageContentsZ {
5174 protected constructor() {}
5177 export function LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5178 if(!isWasmInitialized) {
5179 throw new Error("initializeWasm() must be awaited first!");
5181 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr);
5182 return nativeResponseValue;
5185 export function LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5186 if(!isWasmInitialized) {
5187 throw new Error("initializeWasm() must be awaited first!");
5189 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr);
5190 return nativeResponseValue;
5192 // struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5194 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5195 if(!isWasmInitialized) {
5196 throw new Error("initializeWasm() must be awaited first!");
5198 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner);
5199 return nativeResponseValue;
5201 // struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5203 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5204 if(!isWasmInitialized) {
5205 throw new Error("initializeWasm() must be awaited first!");
5207 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner);
5208 return nativeResponseValue;
5211 export class LDKCOption_NetAddressZ {
5212 protected constructor() {}
5215 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
5216 if(!isWasmInitialized) {
5217 throw new Error("initializeWasm() must be awaited first!");
5219 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
5220 return nativeResponseValue;
5223 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
5224 if(!isWasmInitialized) {
5225 throw new Error("initializeWasm() must be awaited first!");
5227 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
5228 return nativeResponseValue;
5230 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5232 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5237 return nativeResponseValue;
5239 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5241 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5242 if(!isWasmInitialized) {
5243 throw new Error("initializeWasm() must be awaited first!");
5245 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5246 return nativeResponseValue;
5248 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5250 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5251 if(!isWasmInitialized) {
5252 throw new Error("initializeWasm() must be awaited first!");
5254 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5255 // debug statements here
5257 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5259 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5260 if(!isWasmInitialized) {
5261 throw new Error("initializeWasm() must be awaited first!");
5263 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5264 return nativeResponseValue;
5266 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5268 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5269 if(!isWasmInitialized) {
5270 throw new Error("initializeWasm() must be awaited first!");
5272 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5273 return nativeResponseValue;
5275 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5277 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5278 if(!isWasmInitialized) {
5279 throw new Error("initializeWasm() must be awaited first!");
5281 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5282 return nativeResponseValue;
5285 export class LDKSendError {
5286 protected constructor() {}
5289 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
5290 if(!isWasmInitialized) {
5291 throw new Error("initializeWasm() must be awaited first!");
5293 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
5294 return nativeResponseValue;
5297 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
5298 if(!isWasmInitialized) {
5299 throw new Error("initializeWasm() must be awaited first!");
5301 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
5302 return nativeResponseValue;
5304 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5306 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
5311 // debug statements here
5313 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
5315 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
5320 return nativeResponseValue;
5323 export class LDKGraphSyncError {
5324 protected constructor() {}
5327 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5328 if(!isWasmInitialized) {
5329 throw new Error("initializeWasm() must be awaited first!");
5331 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5332 return nativeResponseValue;
5335 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5336 if(!isWasmInitialized) {
5337 throw new Error("initializeWasm() must be awaited first!");
5339 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5340 return nativeResponseValue;
5343 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5344 if(!isWasmInitialized) {
5345 throw new Error("initializeWasm() must be awaited first!");
5347 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5348 return nativeResponseValue;
5350 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5352 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5353 if(!isWasmInitialized) {
5354 throw new Error("initializeWasm() must be awaited first!");
5356 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5357 return nativeResponseValue;
5359 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5361 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5362 if(!isWasmInitialized) {
5363 throw new Error("initializeWasm() must be awaited first!");
5365 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5366 return nativeResponseValue;
5369 export class LDKParseError {
5370 protected constructor() {}
5373 export function LDKParseError_ty_from_ptr(ptr: bigint): number {
5374 if(!isWasmInitialized) {
5375 throw new Error("initializeWasm() must be awaited first!");
5377 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
5378 return nativeResponseValue;
5381 export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
5382 if(!isWasmInitialized) {
5383 throw new Error("initializeWasm() must be awaited first!");
5385 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
5386 return nativeResponseValue;
5389 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
5390 if(!isWasmInitialized) {
5391 throw new Error("initializeWasm() must be awaited first!");
5393 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
5394 return nativeResponseValue;
5397 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
5398 if(!isWasmInitialized) {
5399 throw new Error("initializeWasm() must be awaited first!");
5401 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
5402 return nativeResponseValue;
5405 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
5410 return nativeResponseValue;
5413 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
5414 if(!isWasmInitialized) {
5415 throw new Error("initializeWasm() must be awaited first!");
5417 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
5418 return nativeResponseValue;
5420 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
5422 export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
5423 if(!isWasmInitialized) {
5424 throw new Error("initializeWasm() must be awaited first!");
5426 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
5427 return nativeResponseValue;
5429 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
5431 export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
5432 if(!isWasmInitialized) {
5433 throw new Error("initializeWasm() must be awaited first!");
5435 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
5436 return nativeResponseValue;
5439 export class LDKParseOrSemanticError {
5440 protected constructor() {}
5443 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
5444 if(!isWasmInitialized) {
5445 throw new Error("initializeWasm() must be awaited first!");
5447 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
5448 return nativeResponseValue;
5451 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
5452 if(!isWasmInitialized) {
5453 throw new Error("initializeWasm() must be awaited first!");
5455 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
5456 return nativeResponseValue;
5459 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
5464 return nativeResponseValue;
5466 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
5468 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
5469 if(!isWasmInitialized) {
5470 throw new Error("initializeWasm() must be awaited first!");
5472 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
5473 return nativeResponseValue;
5475 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
5477 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
5478 if(!isWasmInitialized) {
5479 throw new Error("initializeWasm() must be awaited first!");
5481 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
5482 return nativeResponseValue;
5484 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
5486 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
5491 return nativeResponseValue;
5493 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
5495 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
5496 if(!isWasmInitialized) {
5497 throw new Error("initializeWasm() must be awaited first!");
5499 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
5500 return nativeResponseValue;
5502 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5504 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
5509 return nativeResponseValue;
5511 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5513 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
5514 if(!isWasmInitialized) {
5515 throw new Error("initializeWasm() must be awaited first!");
5517 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
5518 return nativeResponseValue;
5520 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
5522 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
5523 if(!isWasmInitialized) {
5524 throw new Error("initializeWasm() must be awaited first!");
5526 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
5527 return nativeResponseValue;
5529 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
5531 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
5532 if(!isWasmInitialized) {
5533 throw new Error("initializeWasm() must be awaited first!");
5535 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
5536 return nativeResponseValue;
5538 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
5540 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
5541 if(!isWasmInitialized) {
5542 throw new Error("initializeWasm() must be awaited first!");
5544 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
5545 return nativeResponseValue;
5547 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
5549 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
5550 if(!isWasmInitialized) {
5551 throw new Error("initializeWasm() must be awaited first!");
5553 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
5554 return nativeResponseValue;
5556 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
5558 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
5563 return nativeResponseValue;
5565 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
5567 export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
5568 if(!isWasmInitialized) {
5569 throw new Error("initializeWasm() must be awaited first!");
5571 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
5572 // debug statements here
5574 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
5576 export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
5577 if(!isWasmInitialized) {
5578 throw new Error("initializeWasm() must be awaited first!");
5580 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
5581 return nativeResponseValue;
5583 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
5585 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
5590 return nativeResponseValue;
5592 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
5594 export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
5599 return nativeResponseValue;
5601 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
5603 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
5608 return nativeResponseValue;
5610 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
5612 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
5617 return nativeResponseValue;
5619 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
5621 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
5626 return nativeResponseValue;
5628 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
5630 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
5635 return nativeResponseValue;
5637 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5639 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
5640 if(!isWasmInitialized) {
5641 throw new Error("initializeWasm() must be awaited first!");
5643 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
5644 // debug statements here
5646 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5648 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
5649 if(!isWasmInitialized) {
5650 throw new Error("initializeWasm() must be awaited first!");
5652 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
5653 return nativeResponseValue;
5655 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5657 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5658 if(!isWasmInitialized) {
5659 throw new Error("initializeWasm() must be awaited first!");
5661 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
5662 return nativeResponseValue;
5664 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5666 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5667 if(!isWasmInitialized) {
5668 throw new Error("initializeWasm() must be awaited first!");
5670 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
5671 return nativeResponseValue;
5673 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5675 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5676 if(!isWasmInitialized) {
5677 throw new Error("initializeWasm() must be awaited first!");
5679 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5680 return nativeResponseValue;
5682 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5684 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5685 if(!isWasmInitialized) {
5686 throw new Error("initializeWasm() must be awaited first!");
5688 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5689 return nativeResponseValue;
5691 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5693 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5694 if(!isWasmInitialized) {
5695 throw new Error("initializeWasm() must be awaited first!");
5697 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5698 return nativeResponseValue;
5700 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5702 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
5703 if(!isWasmInitialized) {
5704 throw new Error("initializeWasm() must be awaited first!");
5706 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5707 return nativeResponseValue;
5709 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5711 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5716 return nativeResponseValue;
5718 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5720 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5725 return nativeResponseValue;
5727 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5729 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5730 if(!isWasmInitialized) {
5731 throw new Error("initializeWasm() must be awaited first!");
5733 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5734 return nativeResponseValue;
5736 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5738 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5739 if(!isWasmInitialized) {
5740 throw new Error("initializeWasm() must be awaited first!");
5742 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5743 return nativeResponseValue;
5745 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5747 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5748 if(!isWasmInitialized) {
5749 throw new Error("initializeWasm() must be awaited first!");
5751 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5752 return nativeResponseValue;
5754 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5756 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5757 if(!isWasmInitialized) {
5758 throw new Error("initializeWasm() must be awaited first!");
5760 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5761 return nativeResponseValue;
5763 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5765 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5770 return nativeResponseValue;
5772 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5774 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5779 return nativeResponseValue;
5781 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5783 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5788 return nativeResponseValue;
5790 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5792 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5797 return nativeResponseValue;
5799 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5801 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5806 return nativeResponseValue;
5808 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5810 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5815 return nativeResponseValue;
5817 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5819 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5824 return nativeResponseValue;
5826 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5828 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5833 return nativeResponseValue;
5835 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5837 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5842 return nativeResponseValue;
5844 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5846 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5851 return nativeResponseValue;
5853 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5855 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5860 return nativeResponseValue;
5862 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5864 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5869 return nativeResponseValue;
5871 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5873 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5878 return nativeResponseValue;
5880 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5882 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5887 return nativeResponseValue;
5889 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5891 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5896 return nativeResponseValue;
5898 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5900 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5905 return nativeResponseValue;
5907 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5909 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5914 return nativeResponseValue;
5916 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5918 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5923 return nativeResponseValue;
5925 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5927 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5932 return nativeResponseValue;
5934 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5936 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5941 return nativeResponseValue;
5943 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5945 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5950 return nativeResponseValue;
5952 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5954 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5959 return nativeResponseValue;
5961 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5963 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5968 return nativeResponseValue;
5970 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5972 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5977 return nativeResponseValue;
5979 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5981 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5986 return nativeResponseValue;
5988 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5990 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5995 return nativeResponseValue;
5997 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
5999 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
6004 return nativeResponseValue;
6006 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6008 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
6013 return nativeResponseValue;
6015 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6017 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
6022 return nativeResponseValue;
6024 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6026 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
6031 return nativeResponseValue;
6033 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6035 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
6040 return nativeResponseValue;
6042 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6044 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
6049 return nativeResponseValue;
6051 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6053 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
6058 return nativeResponseValue;
6060 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6062 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
6067 return nativeResponseValue;
6069 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6071 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
6076 return nativeResponseValue;
6078 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6080 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
6085 return nativeResponseValue;
6087 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6089 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
6094 return nativeResponseValue;
6096 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6098 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
6103 return nativeResponseValue;
6105 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6107 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
6112 return nativeResponseValue;
6114 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6116 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
6121 return nativeResponseValue;
6123 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6125 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
6130 return nativeResponseValue;
6132 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6134 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
6139 return nativeResponseValue;
6141 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6143 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
6148 return nativeResponseValue;
6150 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6152 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
6157 return nativeResponseValue;
6159 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6161 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
6166 return nativeResponseValue;
6168 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6170 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
6175 return nativeResponseValue;
6177 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6179 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
6184 return nativeResponseValue;
6186 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6188 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
6193 return nativeResponseValue;
6195 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6197 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
6202 return nativeResponseValue;
6204 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6206 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
6211 return nativeResponseValue;
6213 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6215 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
6220 return nativeResponseValue;
6222 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6224 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
6229 return nativeResponseValue;
6231 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6233 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
6238 return nativeResponseValue;
6240 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6242 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
6247 return nativeResponseValue;
6249 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6251 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
6256 return nativeResponseValue;
6258 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6260 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
6265 return nativeResponseValue;
6267 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6269 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
6274 return nativeResponseValue;
6276 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6278 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
6283 return nativeResponseValue;
6286 export class LDKSignOrCreationError {
6287 protected constructor() {}
6290 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
6295 return nativeResponseValue;
6298 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
6299 if(!isWasmInitialized) {
6300 throw new Error("initializeWasm() must be awaited first!");
6302 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
6303 return nativeResponseValue;
6305 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6307 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
6308 if(!isWasmInitialized) {
6309 throw new Error("initializeWasm() must be awaited first!");
6311 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
6312 return nativeResponseValue;
6314 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6316 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
6317 if(!isWasmInitialized) {
6318 throw new Error("initializeWasm() must be awaited first!");
6320 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
6321 return nativeResponseValue;
6324 export interface LDKFilter {
6325 register_tx (txid: number, script_pubkey: number): void;
6326 register_output (output: bigint): void;
6330 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
6331 if(!isWasmInitialized) {
6332 throw new Error("initializeWasm() must be awaited first!");
6334 var new_obj_idx = js_objs.length;
6335 for (var i = 0; i < js_objs.length; i++) {
6336 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6338 js_objs[i] = new WeakRef(impl);
6339 return [wasm.TS_LDKFilter_new(i), i];
6341 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
6343 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
6344 if(!isWasmInitialized) {
6345 throw new Error("initializeWasm() must be awaited first!");
6347 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
6348 // debug statements here
6350 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
6352 export function Filter_register_output(this_arg: bigint, output: bigint): void {
6353 if(!isWasmInitialized) {
6354 throw new Error("initializeWasm() must be awaited first!");
6356 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
6357 // debug statements here
6360 export class LDKCOption_FilterZ {
6361 protected constructor() {}
6364 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
6365 if(!isWasmInitialized) {
6366 throw new Error("initializeWasm() must be awaited first!");
6368 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
6369 return nativeResponseValue;
6372 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
6373 if(!isWasmInitialized) {
6374 throw new Error("initializeWasm() must be awaited first!");
6376 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
6377 return nativeResponseValue;
6379 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6381 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
6382 if(!isWasmInitialized) {
6383 throw new Error("initializeWasm() must be awaited first!");
6385 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
6386 return nativeResponseValue;
6388 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
6390 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
6391 if(!isWasmInitialized) {
6392 throw new Error("initializeWasm() must be awaited first!");
6394 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
6395 // debug statements here
6397 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
6399 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
6400 if(!isWasmInitialized) {
6401 throw new Error("initializeWasm() must be awaited first!");
6403 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
6404 return nativeResponseValue;
6406 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
6408 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
6409 if(!isWasmInitialized) {
6410 throw new Error("initializeWasm() must be awaited first!");
6412 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
6413 return nativeResponseValue;
6416 export interface LDKMessageSendEventsProvider {
6417 get_and_clear_pending_msg_events (): number;
6421 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 var new_obj_idx = js_objs.length;
6426 for (var i = 0; i < js_objs.length; i++) {
6427 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6429 js_objs[i] = new WeakRef(impl);
6430 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
6432 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
6434 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
6435 if(!isWasmInitialized) {
6436 throw new Error("initializeWasm() must be awaited first!");
6438 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
6439 return nativeResponseValue;
6442 export interface LDKOnionMessageProvider {
6443 next_onion_message_for_peer (peer_node_id: number): bigint;
6447 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
6448 if(!isWasmInitialized) {
6449 throw new Error("initializeWasm() must be awaited first!");
6451 var new_obj_idx = js_objs.length;
6452 for (var i = 0; i < js_objs.length; i++) {
6453 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6455 js_objs[i] = new WeakRef(impl);
6456 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
6458 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
6460 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
6461 if(!isWasmInitialized) {
6462 throw new Error("initializeWasm() must be awaited first!");
6464 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
6465 return nativeResponseValue;
6468 export interface LDKEventHandler {
6469 handle_event (event: bigint): void;
6473 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
6474 if(!isWasmInitialized) {
6475 throw new Error("initializeWasm() must be awaited first!");
6477 var new_obj_idx = js_objs.length;
6478 for (var i = 0; i < js_objs.length; i++) {
6479 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6481 js_objs[i] = new WeakRef(impl);
6482 return [wasm.TS_LDKEventHandler_new(i), i];
6484 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
6486 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
6487 if(!isWasmInitialized) {
6488 throw new Error("initializeWasm() must be awaited first!");
6490 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
6491 // debug statements here
6494 export interface LDKEventsProvider {
6495 process_pending_events (handler: bigint): void;
6499 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
6500 if(!isWasmInitialized) {
6501 throw new Error("initializeWasm() must be awaited first!");
6503 var new_obj_idx = js_objs.length;
6504 for (var i = 0; i < js_objs.length; i++) {
6505 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6507 js_objs[i] = new WeakRef(impl);
6508 return [wasm.TS_LDKEventsProvider_new(i), i];
6510 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
6512 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
6517 // debug statements here
6520 export interface LDKScore {
6521 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
6522 payment_path_failed (path: number, short_channel_id: bigint): void;
6523 payment_path_successful (path: number): void;
6524 probe_failed (path: number, short_channel_id: bigint): void;
6525 probe_successful (path: number): void;
6530 export function LDKScore_new(impl: LDKScore): [bigint, number] {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 var new_obj_idx = js_objs.length;
6535 for (var i = 0; i < js_objs.length; i++) {
6536 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6538 js_objs[i] = new WeakRef(impl);
6539 return [wasm.TS_LDKScore_new(i), i];
6541 // 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
6543 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint {
6544 if(!isWasmInitialized) {
6545 throw new Error("initializeWasm() must be awaited first!");
6547 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
6548 return nativeResponseValue;
6550 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6552 export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6553 if(!isWasmInitialized) {
6554 throw new Error("initializeWasm() must be awaited first!");
6556 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
6557 // debug statements here
6559 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6561 export function Score_payment_path_successful(this_arg: bigint, path: number): void {
6562 if(!isWasmInitialized) {
6563 throw new Error("initializeWasm() must be awaited first!");
6565 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
6566 // debug statements here
6568 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6570 export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
6571 if(!isWasmInitialized) {
6572 throw new Error("initializeWasm() must be awaited first!");
6574 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
6575 // debug statements here
6577 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6579 export function Score_probe_successful(this_arg: bigint, path: number): void {
6580 if(!isWasmInitialized) {
6581 throw new Error("initializeWasm() must be awaited first!");
6583 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
6584 // debug statements here
6586 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
6588 export function Score_write(this_arg: bigint): number {
6589 if(!isWasmInitialized) {
6590 throw new Error("initializeWasm() must be awaited first!");
6592 const nativeResponseValue = wasm.TS_Score_write(this_arg);
6593 return nativeResponseValue;
6596 export interface LDKLockableScore {
6601 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
6602 if(!isWasmInitialized) {
6603 throw new Error("initializeWasm() must be awaited first!");
6605 var new_obj_idx = js_objs.length;
6606 for (var i = 0; i < js_objs.length; i++) {
6607 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6609 js_objs[i] = new WeakRef(impl);
6610 return [wasm.TS_LDKLockableScore_new(i), i];
6612 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6614 export function LockableScore_lock(this_arg: bigint): bigint {
6615 if(!isWasmInitialized) {
6616 throw new Error("initializeWasm() must be awaited first!");
6618 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6619 return nativeResponseValue;
6622 export interface LDKWriteableScore {
6627 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
6628 if(!isWasmInitialized) {
6629 throw new Error("initializeWasm() must be awaited first!");
6631 var new_obj_idx = js_objs.length;
6632 for (var i = 0; i < js_objs.length; i++) {
6633 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6635 js_objs[i] = new WeakRef(impl);
6636 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
6638 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
6640 export function WriteableScore_write(this_arg: bigint): number {
6641 if(!isWasmInitialized) {
6642 throw new Error("initializeWasm() must be awaited first!");
6644 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
6645 return nativeResponseValue;
6648 export interface LDKPersister {
6649 persist_manager (channel_manager: bigint): bigint;
6650 persist_graph (network_graph: bigint): bigint;
6651 persist_scorer (scorer: bigint): bigint;
6655 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
6656 if(!isWasmInitialized) {
6657 throw new Error("initializeWasm() must be awaited first!");
6659 var new_obj_idx = js_objs.length;
6660 for (var i = 0; i < js_objs.length; i++) {
6661 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6663 js_objs[i] = new WeakRef(impl);
6664 return [wasm.TS_LDKPersister_new(i), i];
6666 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
6668 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
6669 if(!isWasmInitialized) {
6670 throw new Error("initializeWasm() must be awaited first!");
6672 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
6673 return nativeResponseValue;
6675 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
6677 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
6678 if(!isWasmInitialized) {
6679 throw new Error("initializeWasm() must be awaited first!");
6681 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
6682 return nativeResponseValue;
6684 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
6686 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
6687 if(!isWasmInitialized) {
6688 throw new Error("initializeWasm() must be awaited first!");
6690 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
6691 return nativeResponseValue;
6694 export interface LDKFutureCallback {
6699 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
6700 if(!isWasmInitialized) {
6701 throw new Error("initializeWasm() must be awaited first!");
6703 var new_obj_idx = js_objs.length;
6704 for (var i = 0; i < js_objs.length; i++) {
6705 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6707 js_objs[i] = new WeakRef(impl);
6708 return [wasm.TS_LDKFutureCallback_new(i), i];
6710 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
6712 export function FutureCallback_call(this_arg: bigint): void {
6713 if(!isWasmInitialized) {
6714 throw new Error("initializeWasm() must be awaited first!");
6716 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
6717 // debug statements here
6720 export interface LDKListen {
6721 filtered_block_connected (header: number, txdata: number, height: number): void;
6722 block_connected (block: number, height: number): void;
6723 block_disconnected (header: number, height: number): void;
6727 export function LDKListen_new(impl: LDKListen): [bigint, number] {
6728 if(!isWasmInitialized) {
6729 throw new Error("initializeWasm() must be awaited first!");
6731 var new_obj_idx = js_objs.length;
6732 for (var i = 0; i < js_objs.length; i++) {
6733 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6735 js_objs[i] = new WeakRef(impl);
6736 return [wasm.TS_LDKListen_new(i), i];
6738 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6740 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
6741 if(!isWasmInitialized) {
6742 throw new Error("initializeWasm() must be awaited first!");
6744 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
6745 // debug statements here
6747 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
6749 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
6750 if(!isWasmInitialized) {
6751 throw new Error("initializeWasm() must be awaited first!");
6753 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
6754 // debug statements here
6756 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6758 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
6759 if(!isWasmInitialized) {
6760 throw new Error("initializeWasm() must be awaited first!");
6762 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
6763 // debug statements here
6766 export interface LDKConfirm {
6767 transactions_confirmed (header: number, txdata: number, height: number): void;
6768 transaction_unconfirmed (txid: number): void;
6769 best_block_updated (header: number, height: number): void;
6770 get_relevant_txids (): number;
6774 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
6775 if(!isWasmInitialized) {
6776 throw new Error("initializeWasm() must be awaited first!");
6778 var new_obj_idx = js_objs.length;
6779 for (var i = 0; i < js_objs.length; i++) {
6780 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6782 js_objs[i] = new WeakRef(impl);
6783 return [wasm.TS_LDKConfirm_new(i), i];
6785 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6787 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
6788 if(!isWasmInitialized) {
6789 throw new Error("initializeWasm() must be awaited first!");
6791 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
6792 // debug statements here
6794 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
6796 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
6797 if(!isWasmInitialized) {
6798 throw new Error("initializeWasm() must be awaited first!");
6800 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
6801 // debug statements here
6803 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6805 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
6806 if(!isWasmInitialized) {
6807 throw new Error("initializeWasm() must be awaited first!");
6809 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
6810 // debug statements here
6812 // LDKCVec_C2Tuple_TxidBlockHashZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6814 export function Confirm_get_relevant_txids(this_arg: bigint): number {
6815 if(!isWasmInitialized) {
6816 throw new Error("initializeWasm() must be awaited first!");
6818 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6819 return nativeResponseValue;
6822 export interface LDKPersist {
6823 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
6824 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
6828 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
6829 if(!isWasmInitialized) {
6830 throw new Error("initializeWasm() must be awaited first!");
6832 var new_obj_idx = js_objs.length;
6833 for (var i = 0; i < js_objs.length; i++) {
6834 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6836 js_objs[i] = new WeakRef(impl);
6837 return [wasm.TS_LDKPersist_new(i), i];
6839 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
6841 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
6842 if(!isWasmInitialized) {
6843 throw new Error("initializeWasm() must be awaited first!");
6845 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6846 return nativeResponseValue;
6848 // LDKChannelMonitorUpdateStatus 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
6850 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
6851 if(!isWasmInitialized) {
6852 throw new Error("initializeWasm() must be awaited first!");
6854 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6855 return nativeResponseValue;
6858 export interface LDKChannelMessageHandler {
6859 handle_open_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6860 handle_accept_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6861 handle_funding_created (their_node_id: number, msg: bigint): void;
6862 handle_funding_signed (their_node_id: number, msg: bigint): void;
6863 handle_channel_ready (their_node_id: number, msg: bigint): void;
6864 handle_shutdown (their_node_id: number, their_features: bigint, msg: bigint): void;
6865 handle_closing_signed (their_node_id: number, msg: bigint): void;
6866 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
6867 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
6868 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
6869 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
6870 handle_commitment_signed (their_node_id: number, msg: bigint): void;
6871 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
6872 handle_update_fee (their_node_id: number, msg: bigint): void;
6873 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
6874 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6875 peer_connected (their_node_id: number, msg: bigint): bigint;
6876 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
6877 handle_channel_update (their_node_id: number, msg: bigint): void;
6878 handle_error (their_node_id: number, msg: bigint): void;
6879 provided_node_features (): bigint;
6880 provided_init_features (their_node_id: number): bigint;
6884 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
6885 if(!isWasmInitialized) {
6886 throw new Error("initializeWasm() must be awaited first!");
6888 var new_obj_idx = js_objs.length;
6889 for (var i = 0; i < js_objs.length; i++) {
6890 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6892 js_objs[i] = new WeakRef(impl);
6893 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
6895 // 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
6897 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6898 if(!isWasmInitialized) {
6899 throw new Error("initializeWasm() must be awaited first!");
6901 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6902 // debug statements here
6904 // 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
6906 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6907 if(!isWasmInitialized) {
6908 throw new Error("initializeWasm() must be awaited first!");
6910 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6911 // debug statements here
6913 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6915 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
6916 if(!isWasmInitialized) {
6917 throw new Error("initializeWasm() must be awaited first!");
6919 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6920 // debug statements here
6922 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6924 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6925 if(!isWasmInitialized) {
6926 throw new Error("initializeWasm() must be awaited first!");
6928 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6929 // debug statements here
6931 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6933 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
6934 if(!isWasmInitialized) {
6935 throw new Error("initializeWasm() must be awaited first!");
6937 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6938 // debug statements here
6940 // 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
6942 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6943 if(!isWasmInitialized) {
6944 throw new Error("initializeWasm() must be awaited first!");
6946 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6947 // debug statements here
6949 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6951 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6952 if(!isWasmInitialized) {
6953 throw new Error("initializeWasm() must be awaited first!");
6955 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6956 // debug statements here
6958 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6960 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6961 if(!isWasmInitialized) {
6962 throw new Error("initializeWasm() must be awaited first!");
6964 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6965 // debug statements here
6967 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6969 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6970 if(!isWasmInitialized) {
6971 throw new Error("initializeWasm() must be awaited first!");
6973 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6974 // debug statements here
6976 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6978 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6979 if(!isWasmInitialized) {
6980 throw new Error("initializeWasm() must be awaited first!");
6982 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6983 // debug statements here
6985 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6987 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6988 if(!isWasmInitialized) {
6989 throw new Error("initializeWasm() must be awaited first!");
6991 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6992 // debug statements here
6994 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6996 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6997 if(!isWasmInitialized) {
6998 throw new Error("initializeWasm() must be awaited first!");
7000 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
7001 // debug statements here
7003 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
7005 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
7006 if(!isWasmInitialized) {
7007 throw new Error("initializeWasm() must be awaited first!");
7009 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
7010 // debug statements here
7012 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
7014 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
7015 if(!isWasmInitialized) {
7016 throw new Error("initializeWasm() must be awaited first!");
7018 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
7019 // debug statements here
7021 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
7023 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
7024 if(!isWasmInitialized) {
7025 throw new Error("initializeWasm() must be awaited first!");
7027 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
7028 // debug statements here
7030 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
7032 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
7033 if(!isWasmInitialized) {
7034 throw new Error("initializeWasm() must be awaited first!");
7036 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
7037 // debug statements here
7039 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
7041 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7042 if(!isWasmInitialized) {
7043 throw new Error("initializeWasm() must be awaited first!");
7045 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
7046 return nativeResponseValue;
7048 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
7050 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
7051 if(!isWasmInitialized) {
7052 throw new Error("initializeWasm() must be awaited first!");
7054 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
7055 // debug statements here
7057 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
7059 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
7060 if(!isWasmInitialized) {
7061 throw new Error("initializeWasm() must be awaited first!");
7063 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
7064 // debug statements here
7066 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
7068 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
7069 if(!isWasmInitialized) {
7070 throw new Error("initializeWasm() must be awaited first!");
7072 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
7073 // debug statements here
7075 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
7077 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
7078 if(!isWasmInitialized) {
7079 throw new Error("initializeWasm() must be awaited first!");
7081 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
7082 return nativeResponseValue;
7084 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7086 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7087 if(!isWasmInitialized) {
7088 throw new Error("initializeWasm() must be awaited first!");
7090 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
7091 return nativeResponseValue;
7094 export interface LDKRoutingMessageHandler {
7095 handle_node_announcement (msg: bigint): bigint;
7096 handle_channel_announcement (msg: bigint): bigint;
7097 handle_channel_update (msg: bigint): bigint;
7098 get_next_channel_announcement (starting_point: bigint): bigint;
7099 get_next_node_announcement (starting_point: number): bigint;
7100 peer_connected (their_node_id: number, init: bigint): bigint;
7101 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
7102 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
7103 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
7104 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
7105 provided_node_features (): bigint;
7106 provided_init_features (their_node_id: number): bigint;
7110 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
7111 if(!isWasmInitialized) {
7112 throw new Error("initializeWasm() must be awaited first!");
7114 var new_obj_idx = js_objs.length;
7115 for (var i = 0; i < js_objs.length; i++) {
7116 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7118 js_objs[i] = new WeakRef(impl);
7119 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
7121 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
7123 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
7124 if(!isWasmInitialized) {
7125 throw new Error("initializeWasm() must be awaited first!");
7127 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
7128 return nativeResponseValue;
7130 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
7132 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
7133 if(!isWasmInitialized) {
7134 throw new Error("initializeWasm() must be awaited first!");
7136 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
7137 return nativeResponseValue;
7139 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
7141 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
7142 if(!isWasmInitialized) {
7143 throw new Error("initializeWasm() must be awaited first!");
7145 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
7146 return nativeResponseValue;
7148 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
7150 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
7151 if(!isWasmInitialized) {
7152 throw new Error("initializeWasm() must be awaited first!");
7154 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
7155 return nativeResponseValue;
7157 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point
7159 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: number): bigint {
7160 if(!isWasmInitialized) {
7161 throw new Error("initializeWasm() must be awaited first!");
7163 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
7164 return nativeResponseValue;
7166 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
7168 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): bigint {
7169 if(!isWasmInitialized) {
7170 throw new Error("initializeWasm() must be awaited first!");
7172 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
7173 return nativeResponseValue;
7175 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
7177 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7178 if(!isWasmInitialized) {
7179 throw new Error("initializeWasm() must be awaited first!");
7181 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
7182 return nativeResponseValue;
7184 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
7186 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7187 if(!isWasmInitialized) {
7188 throw new Error("initializeWasm() must be awaited first!");
7190 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
7191 return nativeResponseValue;
7193 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
7195 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7196 if(!isWasmInitialized) {
7197 throw new Error("initializeWasm() must be awaited first!");
7199 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
7200 return nativeResponseValue;
7202 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
7204 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
7205 if(!isWasmInitialized) {
7206 throw new Error("initializeWasm() must be awaited first!");
7208 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
7209 return nativeResponseValue;
7211 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
7213 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
7214 if(!isWasmInitialized) {
7215 throw new Error("initializeWasm() must be awaited first!");
7217 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
7218 return nativeResponseValue;
7220 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7222 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7223 if(!isWasmInitialized) {
7224 throw new Error("initializeWasm() must be awaited first!");
7226 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
7227 return nativeResponseValue;
7230 export interface LDKOnionMessageHandler {
7231 handle_onion_message (peer_node_id: number, msg: bigint): void;
7232 peer_connected (their_node_id: number, init: bigint): bigint;
7233 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
7234 provided_node_features (): bigint;
7235 provided_init_features (their_node_id: number): bigint;
7239 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
7240 if(!isWasmInitialized) {
7241 throw new Error("initializeWasm() must be awaited first!");
7243 var new_obj_idx = js_objs.length;
7244 for (var i = 0; i < js_objs.length; i++) {
7245 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7247 js_objs[i] = new WeakRef(impl);
7248 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
7250 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
7252 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
7253 if(!isWasmInitialized) {
7254 throw new Error("initializeWasm() must be awaited first!");
7256 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
7257 // debug statements here
7259 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
7261 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): bigint {
7262 if(!isWasmInitialized) {
7263 throw new Error("initializeWasm() must be awaited first!");
7265 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init);
7266 return nativeResponseValue;
7268 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
7270 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
7271 if(!isWasmInitialized) {
7272 throw new Error("initializeWasm() must be awaited first!");
7274 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
7275 // debug statements here
7277 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
7279 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
7284 return nativeResponseValue;
7286 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
7288 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
7289 if(!isWasmInitialized) {
7290 throw new Error("initializeWasm() must be awaited first!");
7292 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
7293 return nativeResponseValue;
7296 export interface LDKCustomMessageReader {
7297 read (message_type: number, buffer: number): bigint;
7301 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
7302 if(!isWasmInitialized) {
7303 throw new Error("initializeWasm() must be awaited first!");
7305 var new_obj_idx = js_objs.length;
7306 for (var i = 0; i < js_objs.length; i++) {
7307 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7309 js_objs[i] = new WeakRef(impl);
7310 return [wasm.TS_LDKCustomMessageReader_new(i), i];
7312 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
7314 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
7315 if(!isWasmInitialized) {
7316 throw new Error("initializeWasm() must be awaited first!");
7318 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
7319 return nativeResponseValue;
7322 export interface LDKCustomMessageHandler {
7323 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
7324 get_and_clear_pending_msg (): number;
7328 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
7329 if(!isWasmInitialized) {
7330 throw new Error("initializeWasm() must be awaited first!");
7332 var new_obj_idx = js_objs.length;
7333 for (var i = 0; i < js_objs.length; i++) {
7334 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7336 js_objs[i] = new WeakRef(impl);
7337 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
7339 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
7341 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
7342 if(!isWasmInitialized) {
7343 throw new Error("initializeWasm() must be awaited first!");
7345 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
7346 return nativeResponseValue;
7348 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
7350 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
7351 if(!isWasmInitialized) {
7352 throw new Error("initializeWasm() must be awaited first!");
7354 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
7355 return nativeResponseValue;
7358 export interface LDKCustomOnionMessageHandler {
7359 handle_custom_message (msg: bigint): void;
7360 read_custom_message (message_type: bigint, buffer: number): bigint;
7364 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
7365 if(!isWasmInitialized) {
7366 throw new Error("initializeWasm() must be awaited first!");
7368 var new_obj_idx = js_objs.length;
7369 for (var i = 0; i < js_objs.length; i++) {
7370 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7372 js_objs[i] = new WeakRef(impl);
7373 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
7375 // void CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKCustomOnionMessageContents msg
7377 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): void {
7378 if(!isWasmInitialized) {
7379 throw new Error("initializeWasm() must be awaited first!");
7381 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
7382 // debug statements here
7384 // LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
7386 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
7387 if(!isWasmInitialized) {
7388 throw new Error("initializeWasm() must be awaited first!");
7390 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
7391 return nativeResponseValue;
7394 export interface LDKSocketDescriptor {
7395 send_data (data: number, resume_read: boolean): number;
7396 disconnect_socket (): void;
7397 eq (other_arg: bigint): boolean;
7402 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
7403 if(!isWasmInitialized) {
7404 throw new Error("initializeWasm() must be awaited first!");
7406 var new_obj_idx = js_objs.length;
7407 for (var i = 0; i < js_objs.length; i++) {
7408 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7410 js_objs[i] = new WeakRef(impl);
7411 return [wasm.TS_LDKSocketDescriptor_new(i), i];
7413 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
7415 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
7416 if(!isWasmInitialized) {
7417 throw new Error("initializeWasm() must be awaited first!");
7419 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
7420 return nativeResponseValue;
7422 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
7424 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
7429 // debug statements here
7431 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
7433 export function SocketDescriptor_hash(this_arg: bigint): bigint {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
7438 return nativeResponseValue;
7441 export class LDKEffectiveCapacity {
7442 protected constructor() {}
7445 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
7446 if(!isWasmInitialized) {
7447 throw new Error("initializeWasm() must be awaited first!");
7449 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
7450 return nativeResponseValue;
7453 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
7454 if(!isWasmInitialized) {
7455 throw new Error("initializeWasm() must be awaited first!");
7457 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
7458 return nativeResponseValue;
7461 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: bigint): bigint {
7462 if(!isWasmInitialized) {
7463 throw new Error("initializeWasm() must be awaited first!");
7465 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
7466 return nativeResponseValue;
7469 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
7474 return nativeResponseValue;
7477 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
7482 return nativeResponseValue;
7485 export interface LDKRouter {
7486 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
7487 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
7488 notify_payment_path_failed (path: number, short_channel_id: bigint): void;
7489 notify_payment_path_successful (path: number): void;
7490 notify_payment_probe_successful (path: number): void;
7491 notify_payment_probe_failed (path: number, short_channel_id: bigint): void;
7495 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
7496 if(!isWasmInitialized) {
7497 throw new Error("initializeWasm() must be awaited first!");
7499 var new_obj_idx = js_objs.length;
7500 for (var i = 0; i < js_objs.length; i++) {
7501 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7503 js_objs[i] = new WeakRef(impl);
7504 return [wasm.TS_LDKRouter_new(i), i];
7506 // LDKCResult_RouteLightningErrorZ Router_find_route LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs
7508 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
7509 if(!isWasmInitialized) {
7510 throw new Error("initializeWasm() must be awaited first!");
7512 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
7513 return nativeResponseValue;
7515 // LDKCResult_RouteLightningErrorZ Router_find_route_with_id LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id
7517 export function Router_find_route_with_id(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint {
7518 if(!isWasmInitialized) {
7519 throw new Error("initializeWasm() must be awaited first!");
7521 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
7522 return nativeResponseValue;
7524 // void Router_notify_payment_path_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7526 export function Router_notify_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7527 if(!isWasmInitialized) {
7528 throw new Error("initializeWasm() must be awaited first!");
7530 const nativeResponseValue = wasm.TS_Router_notify_payment_path_failed(this_arg, path, short_channel_id);
7531 // debug statements here
7533 // void Router_notify_payment_path_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7535 export function Router_notify_payment_path_successful(this_arg: bigint, path: number): void {
7536 if(!isWasmInitialized) {
7537 throw new Error("initializeWasm() must be awaited first!");
7539 const nativeResponseValue = wasm.TS_Router_notify_payment_path_successful(this_arg, path);
7540 // debug statements here
7542 // void Router_notify_payment_probe_successful LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
7544 export function Router_notify_payment_probe_successful(this_arg: bigint, path: number): void {
7545 if(!isWasmInitialized) {
7546 throw new Error("initializeWasm() must be awaited first!");
7548 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_successful(this_arg, path);
7549 // debug statements here
7551 // void Router_notify_payment_probe_failed LDKRouter *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
7553 export function Router_notify_payment_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
7554 if(!isWasmInitialized) {
7555 throw new Error("initializeWasm() must be awaited first!");
7557 const nativeResponseValue = wasm.TS_Router_notify_payment_probe_failed(this_arg, path, short_channel_id);
7558 // debug statements here
7561 export class LDKDestination {
7562 protected constructor() {}
7565 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
7570 return nativeResponseValue;
7573 export function LDKDestination_Node_get_node(ptr: bigint): number {
7574 if(!isWasmInitialized) {
7575 throw new Error("initializeWasm() must be awaited first!");
7577 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
7578 return nativeResponseValue;
7581 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
7582 if(!isWasmInitialized) {
7583 throw new Error("initializeWasm() must be awaited first!");
7585 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
7586 return nativeResponseValue;
7589 export class LDKOnionMessageContents {
7590 protected constructor() {}
7593 export function LDKOnionMessageContents_ty_from_ptr(ptr: bigint): number {
7594 if(!isWasmInitialized) {
7595 throw new Error("initializeWasm() must be awaited first!");
7597 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_ty_from_ptr(ptr);
7598 return nativeResponseValue;
7601 export function LDKOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
7602 if(!isWasmInitialized) {
7603 throw new Error("initializeWasm() must be awaited first!");
7605 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Custom_get_custom(ptr);
7606 return nativeResponseValue;
7609 export class LDKFallback {
7610 protected constructor() {}
7613 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
7614 if(!isWasmInitialized) {
7615 throw new Error("initializeWasm() must be awaited first!");
7617 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
7618 return nativeResponseValue;
7621 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
7626 return nativeResponseValue;
7629 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
7630 if(!isWasmInitialized) {
7631 throw new Error("initializeWasm() must be awaited first!");
7633 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
7634 return nativeResponseValue;
7637 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
7642 return nativeResponseValue;
7645 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
7646 if(!isWasmInitialized) {
7647 throw new Error("initializeWasm() must be awaited first!");
7649 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
7650 return nativeResponseValue;
7653 export interface LDKPayer {
7655 first_hops (): number;
7656 send_payment (route: bigint, payment_hash: number, payment_secret: number, payment_id: number): bigint;
7657 send_spontaneous_payment (route: bigint, payment_preimage: number, payment_id: number): bigint;
7658 retry_payment (route: bigint, payment_id: number): bigint;
7659 abandon_payment (payment_id: number): void;
7660 inflight_htlcs (): bigint;
7664 export function LDKPayer_new(impl: LDKPayer): [bigint, number] {
7665 if(!isWasmInitialized) {
7666 throw new Error("initializeWasm() must be awaited first!");
7668 var new_obj_idx = js_objs.length;
7669 for (var i = 0; i < js_objs.length; i++) {
7670 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
7672 js_objs[i] = new WeakRef(impl);
7673 return [wasm.TS_LDKPayer_new(i), i];
7675 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
7677 export function Payer_node_id(this_arg: bigint): number {
7678 if(!isWasmInitialized) {
7679 throw new Error("initializeWasm() must be awaited first!");
7681 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
7682 return nativeResponseValue;
7684 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
7686 export function Payer_first_hops(this_arg: bigint): number {
7687 if(!isWasmInitialized) {
7688 throw new Error("initializeWasm() must be awaited first!");
7690 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
7691 return nativeResponseValue;
7693 // LDKCResult_NonePaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id
7695 export function Payer_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number, payment_id: number): bigint {
7696 if(!isWasmInitialized) {
7697 throw new Error("initializeWasm() must be awaited first!");
7699 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret, payment_id);
7700 return nativeResponseValue;
7702 // LDKCResult_NonePaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id
7704 export function Payer_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number, payment_id: number): bigint {
7705 if(!isWasmInitialized) {
7706 throw new Error("initializeWasm() must be awaited first!");
7708 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage, payment_id);
7709 return nativeResponseValue;
7711 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
7713 export function Payer_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
7714 if(!isWasmInitialized) {
7715 throw new Error("initializeWasm() must be awaited first!");
7717 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
7718 return nativeResponseValue;
7720 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
7722 export function Payer_abandon_payment(this_arg: bigint, payment_id: number): void {
7723 if(!isWasmInitialized) {
7724 throw new Error("initializeWasm() must be awaited first!");
7726 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
7727 // debug statements here
7729 // LDKInFlightHtlcs Payer_inflight_htlcs LDKPayer *NONNULL_PTR this_arg
7731 export function Payer_inflight_htlcs(this_arg: bigint): bigint {
7732 if(!isWasmInitialized) {
7733 throw new Error("initializeWasm() must be awaited first!");
7735 const nativeResponseValue = wasm.TS_Payer_inflight_htlcs(this_arg);
7736 return nativeResponseValue;
7739 export class LDKRetry {
7740 protected constructor() {}
7743 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
7744 if(!isWasmInitialized) {
7745 throw new Error("initializeWasm() must be awaited first!");
7747 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
7748 return nativeResponseValue;
7751 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
7752 if(!isWasmInitialized) {
7753 throw new Error("initializeWasm() must be awaited first!");
7755 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
7756 return nativeResponseValue;
7758 // struct LDKStr _ldk_get_compiled_version(void);
7760 export function _ldk_get_compiled_version(): number {
7761 if(!isWasmInitialized) {
7762 throw new Error("initializeWasm() must be awaited first!");
7764 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
7765 return nativeResponseValue;
7767 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
7769 export function _ldk_c_bindings_get_compiled_version(): number {
7770 if(!isWasmInitialized) {
7771 throw new Error("initializeWasm() must be awaited first!");
7773 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
7774 return nativeResponseValue;
7776 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
7778 export function U128_le_bytes(val: number): number {
7779 if(!isWasmInitialized) {
7780 throw new Error("initializeWasm() must be awaited first!");
7782 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
7783 return nativeResponseValue;
7785 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
7787 export function U128_new(le_bytes: number): number {
7788 if(!isWasmInitialized) {
7789 throw new Error("initializeWasm() must be awaited first!");
7791 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
7792 return nativeResponseValue;
7794 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
7796 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
7797 if(!isWasmInitialized) {
7798 throw new Error("initializeWasm() must be awaited first!");
7800 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
7801 return nativeResponseValue;
7803 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
7805 export function Bech32Error_clone_ptr(arg: bigint): bigint {
7806 if(!isWasmInitialized) {
7807 throw new Error("initializeWasm() must be awaited first!");
7809 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
7810 return nativeResponseValue;
7812 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
7814 export function Bech32Error_clone(orig: bigint): bigint {
7815 if(!isWasmInitialized) {
7816 throw new Error("initializeWasm() must be awaited first!");
7818 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
7819 return nativeResponseValue;
7821 // void Bech32Error_free(struct LDKBech32Error o);
7823 export function Bech32Error_free(o: bigint): void {
7824 if(!isWasmInitialized) {
7825 throw new Error("initializeWasm() must be awaited first!");
7827 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
7828 // debug statements here
7830 // void Transaction_free(struct LDKTransaction _res);
7832 export function Transaction_free(_res: number): void {
7833 if(!isWasmInitialized) {
7834 throw new Error("initializeWasm() must be awaited first!");
7836 const nativeResponseValue = wasm.TS_Transaction_free(_res);
7837 // debug statements here
7839 // void Witness_free(struct LDKWitness _res);
7841 export function Witness_free(_res: number): void {
7842 if(!isWasmInitialized) {
7843 throw new Error("initializeWasm() must be awaited first!");
7845 const nativeResponseValue = wasm.TS_Witness_free(_res);
7846 // debug statements here
7848 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
7850 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
7851 if(!isWasmInitialized) {
7852 throw new Error("initializeWasm() must be awaited first!");
7854 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
7855 return nativeResponseValue;
7857 // void TxOut_free(struct LDKTxOut _res);
7859 export function TxOut_free(_res: bigint): void {
7860 if(!isWasmInitialized) {
7861 throw new Error("initializeWasm() must be awaited first!");
7863 const nativeResponseValue = wasm.TS_TxOut_free(_res);
7864 // debug statements here
7866 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
7868 export function TxOut_clone_ptr(arg: bigint): bigint {
7869 if(!isWasmInitialized) {
7870 throw new Error("initializeWasm() must be awaited first!");
7872 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
7873 return nativeResponseValue;
7875 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
7877 export function TxOut_clone(orig: bigint): bigint {
7878 if(!isWasmInitialized) {
7879 throw new Error("initializeWasm() must be awaited first!");
7881 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
7882 return nativeResponseValue;
7884 // void Str_free(struct LDKStr _res);
7886 export function Str_free(_res: number): void {
7887 if(!isWasmInitialized) {
7888 throw new Error("initializeWasm() must be awaited first!");
7890 const nativeResponseValue = wasm.TS_Str_free(_res);
7891 // debug statements here
7893 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
7895 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
7896 if(!isWasmInitialized) {
7897 throw new Error("initializeWasm() must be awaited first!");
7899 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
7900 return nativeResponseValue;
7902 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
7904 export function COption_HTLCClaimZ_none(): bigint {
7905 if(!isWasmInitialized) {
7906 throw new Error("initializeWasm() must be awaited first!");
7908 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
7909 return nativeResponseValue;
7911 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
7913 export function COption_HTLCClaimZ_free(_res: bigint): void {
7914 if(!isWasmInitialized) {
7915 throw new Error("initializeWasm() must be awaited first!");
7917 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
7918 // debug statements here
7920 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
7922 export function CResult_NoneNoneZ_ok(): bigint {
7923 if(!isWasmInitialized) {
7924 throw new Error("initializeWasm() must be awaited first!");
7926 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
7927 return nativeResponseValue;
7929 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
7931 export function CResult_NoneNoneZ_err(): bigint {
7932 if(!isWasmInitialized) {
7933 throw new Error("initializeWasm() must be awaited first!");
7935 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
7936 return nativeResponseValue;
7938 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
7940 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
7941 if(!isWasmInitialized) {
7942 throw new Error("initializeWasm() must be awaited first!");
7944 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
7945 return nativeResponseValue;
7947 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
7949 export function CResult_NoneNoneZ_free(_res: bigint): void {
7950 if(!isWasmInitialized) {
7951 throw new Error("initializeWasm() must be awaited first!");
7953 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
7954 // debug statements here
7956 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
7958 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
7959 if(!isWasmInitialized) {
7960 throw new Error("initializeWasm() must be awaited first!");
7962 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
7963 return nativeResponseValue;
7965 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
7967 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
7968 if(!isWasmInitialized) {
7969 throw new Error("initializeWasm() must be awaited first!");
7971 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
7972 return nativeResponseValue;
7974 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
7976 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
7977 if(!isWasmInitialized) {
7978 throw new Error("initializeWasm() must be awaited first!");
7980 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
7981 return nativeResponseValue;
7983 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
7985 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
7986 if(!isWasmInitialized) {
7987 throw new Error("initializeWasm() must be awaited first!");
7989 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
7990 return nativeResponseValue;
7992 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
7994 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
7995 if(!isWasmInitialized) {
7996 throw new Error("initializeWasm() must be awaited first!");
7998 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
7999 return nativeResponseValue;
8001 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
8003 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
8004 if(!isWasmInitialized) {
8005 throw new Error("initializeWasm() must be awaited first!");
8007 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
8008 // debug statements here
8010 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
8012 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8013 if(!isWasmInitialized) {
8014 throw new Error("initializeWasm() must be awaited first!");
8016 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
8017 return nativeResponseValue;
8019 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
8021 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
8022 if(!isWasmInitialized) {
8023 throw new Error("initializeWasm() must be awaited first!");
8025 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
8026 return nativeResponseValue;
8028 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
8030 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
8031 if(!isWasmInitialized) {
8032 throw new Error("initializeWasm() must be awaited first!");
8034 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
8035 return nativeResponseValue;
8037 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
8039 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
8040 if(!isWasmInitialized) {
8041 throw new Error("initializeWasm() must be awaited first!");
8043 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
8044 return nativeResponseValue;
8046 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
8048 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
8049 if(!isWasmInitialized) {
8050 throw new Error("initializeWasm() must be awaited first!");
8052 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
8053 return nativeResponseValue;
8055 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
8057 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
8058 if(!isWasmInitialized) {
8059 throw new Error("initializeWasm() must be awaited first!");
8061 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
8062 // debug statements here
8064 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
8066 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8067 if(!isWasmInitialized) {
8068 throw new Error("initializeWasm() must be awaited first!");
8070 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
8071 return nativeResponseValue;
8073 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
8075 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
8076 if(!isWasmInitialized) {
8077 throw new Error("initializeWasm() must be awaited first!");
8079 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
8080 return nativeResponseValue;
8082 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
8084 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
8085 if(!isWasmInitialized) {
8086 throw new Error("initializeWasm() must be awaited first!");
8088 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
8089 return nativeResponseValue;
8091 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
8093 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
8094 if(!isWasmInitialized) {
8095 throw new Error("initializeWasm() must be awaited first!");
8097 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
8098 return nativeResponseValue;
8100 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
8102 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
8103 if(!isWasmInitialized) {
8104 throw new Error("initializeWasm() must be awaited first!");
8106 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
8107 return nativeResponseValue;
8109 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
8111 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
8112 if(!isWasmInitialized) {
8113 throw new Error("initializeWasm() must be awaited first!");
8115 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
8116 // debug statements here
8118 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
8120 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8121 if(!isWasmInitialized) {
8122 throw new Error("initializeWasm() must be awaited first!");
8124 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
8125 return nativeResponseValue;
8127 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
8129 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
8130 if(!isWasmInitialized) {
8131 throw new Error("initializeWasm() must be awaited first!");
8133 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
8134 return nativeResponseValue;
8136 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
8138 export function COption_u32Z_some(o: number): bigint {
8139 if(!isWasmInitialized) {
8140 throw new Error("initializeWasm() must be awaited first!");
8142 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
8143 return nativeResponseValue;
8145 // struct LDKCOption_u32Z COption_u32Z_none(void);
8147 export function COption_u32Z_none(): bigint {
8148 if(!isWasmInitialized) {
8149 throw new Error("initializeWasm() must be awaited first!");
8151 const nativeResponseValue = wasm.TS_COption_u32Z_none();
8152 return nativeResponseValue;
8154 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
8156 export function COption_u32Z_free(_res: bigint): void {
8157 if(!isWasmInitialized) {
8158 throw new Error("initializeWasm() must be awaited first!");
8160 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
8161 // debug statements here
8163 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
8165 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
8166 if(!isWasmInitialized) {
8167 throw new Error("initializeWasm() must be awaited first!");
8169 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
8170 return nativeResponseValue;
8172 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
8174 export function COption_u32Z_clone(orig: bigint): bigint {
8175 if(!isWasmInitialized) {
8176 throw new Error("initializeWasm() must be awaited first!");
8178 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
8179 return nativeResponseValue;
8181 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
8183 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
8188 return nativeResponseValue;
8190 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
8192 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
8193 if(!isWasmInitialized) {
8194 throw new Error("initializeWasm() must be awaited first!");
8196 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
8197 return nativeResponseValue;
8199 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
8201 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
8202 if(!isWasmInitialized) {
8203 throw new Error("initializeWasm() must be awaited first!");
8205 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
8206 return nativeResponseValue;
8208 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
8210 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
8211 if(!isWasmInitialized) {
8212 throw new Error("initializeWasm() must be awaited first!");
8214 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
8215 // debug statements here
8217 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
8219 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8220 if(!isWasmInitialized) {
8221 throw new Error("initializeWasm() must be awaited first!");
8223 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
8224 return nativeResponseValue;
8226 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
8228 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
8229 if(!isWasmInitialized) {
8230 throw new Error("initializeWasm() must be awaited first!");
8232 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
8233 return nativeResponseValue;
8235 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
8237 export function COption_NoneZ_some(): COption_NoneZ {
8238 if(!isWasmInitialized) {
8239 throw new Error("initializeWasm() must be awaited first!");
8241 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
8242 return nativeResponseValue;
8244 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
8246 export function COption_NoneZ_none(): COption_NoneZ {
8247 if(!isWasmInitialized) {
8248 throw new Error("initializeWasm() must be awaited first!");
8250 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
8251 return nativeResponseValue;
8253 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
8255 export function COption_NoneZ_free(_res: COption_NoneZ): void {
8256 if(!isWasmInitialized) {
8257 throw new Error("initializeWasm() must be awaited first!");
8259 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
8260 // debug statements here
8262 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
8264 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8265 if(!isWasmInitialized) {
8266 throw new Error("initializeWasm() must be awaited first!");
8268 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
8269 return nativeResponseValue;
8271 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8273 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8274 if(!isWasmInitialized) {
8275 throw new Error("initializeWasm() must be awaited first!");
8277 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
8278 return nativeResponseValue;
8280 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8282 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8283 if(!isWasmInitialized) {
8284 throw new Error("initializeWasm() must be awaited first!");
8286 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
8287 return nativeResponseValue;
8289 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
8291 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8292 if(!isWasmInitialized) {
8293 throw new Error("initializeWasm() must be awaited first!");
8295 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
8296 // debug statements here
8298 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8300 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8301 if(!isWasmInitialized) {
8302 throw new Error("initializeWasm() must be awaited first!");
8304 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8305 return nativeResponseValue;
8307 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8309 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8310 if(!isWasmInitialized) {
8311 throw new Error("initializeWasm() must be awaited first!");
8313 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
8314 return nativeResponseValue;
8316 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
8318 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
8319 if(!isWasmInitialized) {
8320 throw new Error("initializeWasm() must be awaited first!");
8322 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
8323 return nativeResponseValue;
8325 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
8327 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
8328 if(!isWasmInitialized) {
8329 throw new Error("initializeWasm() must be awaited first!");
8331 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
8332 return nativeResponseValue;
8334 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
8336 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8337 if(!isWasmInitialized) {
8338 throw new Error("initializeWasm() must be awaited first!");
8340 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
8341 return nativeResponseValue;
8343 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
8345 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
8346 if(!isWasmInitialized) {
8347 throw new Error("initializeWasm() must be awaited first!");
8349 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
8350 // debug statements here
8352 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
8354 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8355 if(!isWasmInitialized) {
8356 throw new Error("initializeWasm() must be awaited first!");
8358 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
8359 return nativeResponseValue;
8361 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
8363 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
8364 if(!isWasmInitialized) {
8365 throw new Error("initializeWasm() must be awaited first!");
8367 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
8368 return nativeResponseValue;
8370 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
8372 export function CVec_SignatureZ_free(_res: number): void {
8373 if(!isWasmInitialized) {
8374 throw new Error("initializeWasm() must be awaited first!");
8376 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
8377 // debug statements here
8379 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
8381 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8382 if(!isWasmInitialized) {
8383 throw new Error("initializeWasm() must be awaited first!");
8385 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
8386 return nativeResponseValue;
8388 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8390 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8391 if(!isWasmInitialized) {
8392 throw new Error("initializeWasm() must be awaited first!");
8394 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
8395 return nativeResponseValue;
8397 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8399 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8400 if(!isWasmInitialized) {
8401 throw new Error("initializeWasm() must be awaited first!");
8403 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
8404 return nativeResponseValue;
8406 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
8408 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8409 if(!isWasmInitialized) {
8410 throw new Error("initializeWasm() must be awaited first!");
8412 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
8413 // debug statements here
8415 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8417 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8418 if(!isWasmInitialized) {
8419 throw new Error("initializeWasm() must be awaited first!");
8421 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8422 return nativeResponseValue;
8424 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8426 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8427 if(!isWasmInitialized) {
8428 throw new Error("initializeWasm() must be awaited first!");
8430 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
8431 return nativeResponseValue;
8433 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
8435 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8436 if(!isWasmInitialized) {
8437 throw new Error("initializeWasm() must be awaited first!");
8439 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
8440 return nativeResponseValue;
8442 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8444 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8445 if(!isWasmInitialized) {
8446 throw new Error("initializeWasm() must be awaited first!");
8448 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
8449 return nativeResponseValue;
8451 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8453 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8454 if(!isWasmInitialized) {
8455 throw new Error("initializeWasm() must be awaited first!");
8457 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
8458 return nativeResponseValue;
8460 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
8462 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8463 if(!isWasmInitialized) {
8464 throw new Error("initializeWasm() must be awaited first!");
8466 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
8467 // debug statements here
8469 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8471 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8472 if(!isWasmInitialized) {
8473 throw new Error("initializeWasm() must be awaited first!");
8475 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8476 return nativeResponseValue;
8478 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8480 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8481 if(!isWasmInitialized) {
8482 throw new Error("initializeWasm() must be awaited first!");
8484 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
8485 return nativeResponseValue;
8487 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
8489 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
8490 if(!isWasmInitialized) {
8491 throw new Error("initializeWasm() must be awaited first!");
8493 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
8494 return nativeResponseValue;
8496 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
8498 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
8499 if(!isWasmInitialized) {
8500 throw new Error("initializeWasm() must be awaited first!");
8502 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
8503 return nativeResponseValue;
8505 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
8507 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
8508 if(!isWasmInitialized) {
8509 throw new Error("initializeWasm() must be awaited first!");
8511 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
8512 return nativeResponseValue;
8514 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
8516 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
8517 if(!isWasmInitialized) {
8518 throw new Error("initializeWasm() must be awaited first!");
8520 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
8521 // debug statements here
8523 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
8525 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
8526 if(!isWasmInitialized) {
8527 throw new Error("initializeWasm() must be awaited first!");
8529 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
8530 return nativeResponseValue;
8532 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
8534 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
8535 if(!isWasmInitialized) {
8536 throw new Error("initializeWasm() must be awaited first!");
8538 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
8539 return nativeResponseValue;
8541 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
8543 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
8544 if(!isWasmInitialized) {
8545 throw new Error("initializeWasm() must be awaited first!");
8547 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
8548 return nativeResponseValue;
8550 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
8552 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
8553 if(!isWasmInitialized) {
8554 throw new Error("initializeWasm() must be awaited first!");
8556 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
8557 // debug statements here
8559 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
8561 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8562 if(!isWasmInitialized) {
8563 throw new Error("initializeWasm() must be awaited first!");
8565 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
8566 return nativeResponseValue;
8568 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
8570 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
8571 if(!isWasmInitialized) {
8572 throw new Error("initializeWasm() must be awaited first!");
8574 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
8575 return nativeResponseValue;
8577 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
8579 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
8580 if(!isWasmInitialized) {
8581 throw new Error("initializeWasm() must be awaited first!");
8583 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
8584 return nativeResponseValue;
8586 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
8588 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
8589 if(!isWasmInitialized) {
8590 throw new Error("initializeWasm() must be awaited first!");
8592 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
8593 return nativeResponseValue;
8595 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
8597 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
8598 if(!isWasmInitialized) {
8599 throw new Error("initializeWasm() must be awaited first!");
8601 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
8602 return nativeResponseValue;
8604 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
8606 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
8607 if(!isWasmInitialized) {
8608 throw new Error("initializeWasm() must be awaited first!");
8610 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
8611 // debug statements here
8613 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
8615 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
8616 if(!isWasmInitialized) {
8617 throw new Error("initializeWasm() must be awaited first!");
8619 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
8620 return nativeResponseValue;
8622 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
8624 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
8625 if(!isWasmInitialized) {
8626 throw new Error("initializeWasm() must be awaited first!");
8628 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
8629 return nativeResponseValue;
8631 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
8633 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
8634 if(!isWasmInitialized) {
8635 throw new Error("initializeWasm() must be awaited first!");
8637 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
8638 return nativeResponseValue;
8640 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
8642 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
8643 if(!isWasmInitialized) {
8644 throw new Error("initializeWasm() must be awaited first!");
8646 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
8647 // debug statements here
8649 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
8651 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
8652 if(!isWasmInitialized) {
8653 throw new Error("initializeWasm() must be awaited first!");
8655 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
8656 return nativeResponseValue;
8658 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
8660 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
8661 if(!isWasmInitialized) {
8662 throw new Error("initializeWasm() must be awaited first!");
8664 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
8665 return nativeResponseValue;
8667 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
8669 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
8670 if(!isWasmInitialized) {
8671 throw new Error("initializeWasm() must be awaited first!");
8673 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
8674 return nativeResponseValue;
8676 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
8678 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
8679 if(!isWasmInitialized) {
8680 throw new Error("initializeWasm() must be awaited first!");
8682 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
8683 return nativeResponseValue;
8685 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
8687 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
8688 if(!isWasmInitialized) {
8689 throw new Error("initializeWasm() must be awaited first!");
8691 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
8692 return nativeResponseValue;
8694 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
8696 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
8697 if(!isWasmInitialized) {
8698 throw new Error("initializeWasm() must be awaited first!");
8700 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
8701 // debug statements here
8703 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
8705 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8706 if(!isWasmInitialized) {
8707 throw new Error("initializeWasm() must be awaited first!");
8709 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
8710 return nativeResponseValue;
8712 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
8714 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
8715 if(!isWasmInitialized) {
8716 throw new Error("initializeWasm() must be awaited first!");
8718 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
8719 return nativeResponseValue;
8721 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
8723 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
8724 if(!isWasmInitialized) {
8725 throw new Error("initializeWasm() must be awaited first!");
8727 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
8728 return nativeResponseValue;
8730 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
8732 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
8733 if(!isWasmInitialized) {
8734 throw new Error("initializeWasm() must be awaited first!");
8736 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
8737 return nativeResponseValue;
8739 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
8741 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
8742 if(!isWasmInitialized) {
8743 throw new Error("initializeWasm() must be awaited first!");
8745 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
8746 return nativeResponseValue;
8748 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
8750 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
8751 if(!isWasmInitialized) {
8752 throw new Error("initializeWasm() must be awaited first!");
8754 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
8755 // debug statements here
8757 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
8759 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
8760 if(!isWasmInitialized) {
8761 throw new Error("initializeWasm() must be awaited first!");
8763 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
8764 return nativeResponseValue;
8766 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
8768 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
8769 if(!isWasmInitialized) {
8770 throw new Error("initializeWasm() must be awaited first!");
8772 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
8773 return nativeResponseValue;
8775 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8777 export function CVec_PublicKeyZ_free(_res: number): void {
8778 if(!isWasmInitialized) {
8779 throw new Error("initializeWasm() must be awaited first!");
8781 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8782 // debug statements here
8784 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
8786 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
8787 if(!isWasmInitialized) {
8788 throw new Error("initializeWasm() must be awaited first!");
8790 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
8791 return nativeResponseValue;
8793 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
8795 export function CResult_BlindedPathNoneZ_err(): bigint {
8796 if(!isWasmInitialized) {
8797 throw new Error("initializeWasm() must be awaited first!");
8799 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
8800 return nativeResponseValue;
8802 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
8804 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
8805 if(!isWasmInitialized) {
8806 throw new Error("initializeWasm() must be awaited first!");
8808 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
8809 return nativeResponseValue;
8811 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
8813 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
8814 if(!isWasmInitialized) {
8815 throw new Error("initializeWasm() must be awaited first!");
8817 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
8818 // debug statements here
8820 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
8822 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
8823 if(!isWasmInitialized) {
8824 throw new Error("initializeWasm() must be awaited first!");
8826 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
8827 return nativeResponseValue;
8829 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
8831 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
8832 if(!isWasmInitialized) {
8833 throw new Error("initializeWasm() must be awaited first!");
8835 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
8836 return nativeResponseValue;
8838 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
8840 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
8841 if(!isWasmInitialized) {
8842 throw new Error("initializeWasm() must be awaited first!");
8844 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
8845 return nativeResponseValue;
8847 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
8849 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
8850 if(!isWasmInitialized) {
8851 throw new Error("initializeWasm() must be awaited first!");
8853 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
8854 return nativeResponseValue;
8856 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
8858 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
8859 if(!isWasmInitialized) {
8860 throw new Error("initializeWasm() must be awaited first!");
8862 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
8863 return nativeResponseValue;
8865 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
8867 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
8868 if(!isWasmInitialized) {
8869 throw new Error("initializeWasm() must be awaited first!");
8871 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
8872 // debug statements here
8874 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
8876 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8877 if(!isWasmInitialized) {
8878 throw new Error("initializeWasm() must be awaited first!");
8880 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
8881 return nativeResponseValue;
8883 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
8885 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
8886 if(!isWasmInitialized) {
8887 throw new Error("initializeWasm() must be awaited first!");
8889 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
8890 return nativeResponseValue;
8892 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
8894 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
8895 if(!isWasmInitialized) {
8896 throw new Error("initializeWasm() must be awaited first!");
8898 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
8899 return nativeResponseValue;
8901 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
8903 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
8904 if(!isWasmInitialized) {
8905 throw new Error("initializeWasm() must be awaited first!");
8907 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
8908 return nativeResponseValue;
8910 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
8912 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
8913 if(!isWasmInitialized) {
8914 throw new Error("initializeWasm() must be awaited first!");
8916 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
8917 return nativeResponseValue;
8919 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
8921 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
8922 if(!isWasmInitialized) {
8923 throw new Error("initializeWasm() must be awaited first!");
8925 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
8926 // debug statements here
8928 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
8930 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8931 if(!isWasmInitialized) {
8932 throw new Error("initializeWasm() must be awaited first!");
8934 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
8935 return nativeResponseValue;
8937 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
8939 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
8940 if(!isWasmInitialized) {
8941 throw new Error("initializeWasm() must be awaited first!");
8943 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
8944 return nativeResponseValue;
8946 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8948 export function CVec_ChannelDetailsZ_free(_res: number): void {
8949 if(!isWasmInitialized) {
8950 throw new Error("initializeWasm() must be awaited first!");
8952 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8953 // debug statements here
8955 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8957 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
8958 if(!isWasmInitialized) {
8959 throw new Error("initializeWasm() must be awaited first!");
8961 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8962 return nativeResponseValue;
8964 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8966 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
8967 if(!isWasmInitialized) {
8968 throw new Error("initializeWasm() must be awaited first!");
8970 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8971 return nativeResponseValue;
8973 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8975 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
8976 if(!isWasmInitialized) {
8977 throw new Error("initializeWasm() must be awaited first!");
8979 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8980 return nativeResponseValue;
8982 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8984 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
8985 if(!isWasmInitialized) {
8986 throw new Error("initializeWasm() must be awaited first!");
8988 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8989 // debug statements here
8991 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8993 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
8994 if(!isWasmInitialized) {
8995 throw new Error("initializeWasm() must be awaited first!");
8997 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8998 return nativeResponseValue;
9000 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
9002 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
9003 if(!isWasmInitialized) {
9004 throw new Error("initializeWasm() must be awaited first!");
9006 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
9007 return nativeResponseValue;
9009 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
9011 export function CVec_RouteHopZ_free(_res: number): void {
9012 if(!isWasmInitialized) {
9013 throw new Error("initializeWasm() must be awaited first!");
9015 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
9016 // debug statements here
9018 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
9020 export function COption_u64Z_some(o: bigint): bigint {
9021 if(!isWasmInitialized) {
9022 throw new Error("initializeWasm() must be awaited first!");
9024 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
9025 return nativeResponseValue;
9027 // struct LDKCOption_u64Z COption_u64Z_none(void);
9029 export function COption_u64Z_none(): bigint {
9030 if(!isWasmInitialized) {
9031 throw new Error("initializeWasm() must be awaited first!");
9033 const nativeResponseValue = wasm.TS_COption_u64Z_none();
9034 return nativeResponseValue;
9036 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
9038 export function COption_u64Z_free(_res: bigint): void {
9039 if(!isWasmInitialized) {
9040 throw new Error("initializeWasm() must be awaited first!");
9042 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
9043 // debug statements here
9045 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
9047 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
9048 if(!isWasmInitialized) {
9049 throw new Error("initializeWasm() must be awaited first!");
9051 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
9052 return nativeResponseValue;
9054 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
9056 export function COption_u64Z_clone(orig: bigint): bigint {
9057 if(!isWasmInitialized) {
9058 throw new Error("initializeWasm() must be awaited first!");
9060 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
9061 return nativeResponseValue;
9063 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
9065 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
9066 if(!isWasmInitialized) {
9067 throw new Error("initializeWasm() must be awaited first!");
9069 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
9070 return nativeResponseValue;
9072 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
9074 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
9075 if(!isWasmInitialized) {
9076 throw new Error("initializeWasm() must be awaited first!");
9078 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
9079 return nativeResponseValue;
9081 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
9083 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
9084 if(!isWasmInitialized) {
9085 throw new Error("initializeWasm() must be awaited first!");
9087 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
9088 return nativeResponseValue;
9090 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
9092 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
9093 if(!isWasmInitialized) {
9094 throw new Error("initializeWasm() must be awaited first!");
9096 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
9097 // debug statements here
9099 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
9101 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9102 if(!isWasmInitialized) {
9103 throw new Error("initializeWasm() must be awaited first!");
9105 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
9106 return nativeResponseValue;
9108 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
9110 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
9111 if(!isWasmInitialized) {
9112 throw new Error("initializeWasm() must be awaited first!");
9114 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
9115 return nativeResponseValue;
9117 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
9119 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
9120 if(!isWasmInitialized) {
9121 throw new Error("initializeWasm() must be awaited first!");
9123 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
9124 return nativeResponseValue;
9126 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
9128 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
9129 if(!isWasmInitialized) {
9130 throw new Error("initializeWasm() must be awaited first!");
9132 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
9133 return nativeResponseValue;
9135 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
9137 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
9138 if(!isWasmInitialized) {
9139 throw new Error("initializeWasm() must be awaited first!");
9141 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
9142 return nativeResponseValue;
9144 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
9146 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
9147 if(!isWasmInitialized) {
9148 throw new Error("initializeWasm() must be awaited first!");
9150 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
9151 // debug statements here
9153 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
9155 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9156 if(!isWasmInitialized) {
9157 throw new Error("initializeWasm() must be awaited first!");
9159 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
9160 return nativeResponseValue;
9162 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
9164 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
9165 if(!isWasmInitialized) {
9166 throw new Error("initializeWasm() must be awaited first!");
9168 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
9169 return nativeResponseValue;
9171 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
9173 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
9174 if(!isWasmInitialized) {
9175 throw new Error("initializeWasm() must be awaited first!");
9177 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
9178 // debug statements here
9180 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
9182 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
9183 if(!isWasmInitialized) {
9184 throw new Error("initializeWasm() must be awaited first!");
9186 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
9187 return nativeResponseValue;
9189 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
9191 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
9192 if(!isWasmInitialized) {
9193 throw new Error("initializeWasm() must be awaited first!");
9195 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
9196 return nativeResponseValue;
9198 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
9200 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
9201 if(!isWasmInitialized) {
9202 throw new Error("initializeWasm() must be awaited first!");
9204 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
9205 return nativeResponseValue;
9207 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
9209 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
9210 if(!isWasmInitialized) {
9211 throw new Error("initializeWasm() must be awaited first!");
9213 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
9214 // debug statements here
9216 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
9218 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9219 if(!isWasmInitialized) {
9220 throw new Error("initializeWasm() must be awaited first!");
9222 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
9223 return nativeResponseValue;
9225 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
9227 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
9228 if(!isWasmInitialized) {
9229 throw new Error("initializeWasm() must be awaited first!");
9231 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
9232 return nativeResponseValue;
9234 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
9236 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
9237 if(!isWasmInitialized) {
9238 throw new Error("initializeWasm() must be awaited first!");
9240 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
9241 return nativeResponseValue;
9243 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
9245 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
9246 if(!isWasmInitialized) {
9247 throw new Error("initializeWasm() must be awaited first!");
9249 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
9250 return nativeResponseValue;
9252 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
9254 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
9255 if(!isWasmInitialized) {
9256 throw new Error("initializeWasm() must be awaited first!");
9258 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
9259 return nativeResponseValue;
9261 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
9263 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
9264 if(!isWasmInitialized) {
9265 throw new Error("initializeWasm() must be awaited first!");
9267 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
9268 // debug statements here
9270 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
9272 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9273 if(!isWasmInitialized) {
9274 throw new Error("initializeWasm() must be awaited first!");
9276 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
9277 return nativeResponseValue;
9279 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
9281 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
9282 if(!isWasmInitialized) {
9283 throw new Error("initializeWasm() must be awaited first!");
9285 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
9286 return nativeResponseValue;
9288 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
9290 export function CVec_RouteHintZ_free(_res: number): void {
9291 if(!isWasmInitialized) {
9292 throw new Error("initializeWasm() must be awaited first!");
9294 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
9295 // debug statements here
9297 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9299 export function CVec_u64Z_free(_res: number): void {
9300 if(!isWasmInitialized) {
9301 throw new Error("initializeWasm() must be awaited first!");
9303 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9304 // debug statements here
9306 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
9308 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
9309 if(!isWasmInitialized) {
9310 throw new Error("initializeWasm() must be awaited first!");
9312 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
9313 return nativeResponseValue;
9315 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
9317 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
9318 if(!isWasmInitialized) {
9319 throw new Error("initializeWasm() must be awaited first!");
9321 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
9322 return nativeResponseValue;
9324 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
9326 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
9327 if(!isWasmInitialized) {
9328 throw new Error("initializeWasm() must be awaited first!");
9330 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
9331 return nativeResponseValue;
9333 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
9335 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
9336 if(!isWasmInitialized) {
9337 throw new Error("initializeWasm() must be awaited first!");
9339 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
9340 // debug statements here
9342 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
9344 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9345 if(!isWasmInitialized) {
9346 throw new Error("initializeWasm() must be awaited first!");
9348 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
9349 return nativeResponseValue;
9351 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
9353 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
9354 if(!isWasmInitialized) {
9355 throw new Error("initializeWasm() must be awaited first!");
9357 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
9358 return nativeResponseValue;
9360 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
9362 export function CVec_RouteHintHopZ_free(_res: number): void {
9363 if(!isWasmInitialized) {
9364 throw new Error("initializeWasm() must be awaited first!");
9366 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
9367 // debug statements here
9369 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
9371 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
9372 if(!isWasmInitialized) {
9373 throw new Error("initializeWasm() must be awaited first!");
9375 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
9376 return nativeResponseValue;
9378 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
9380 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
9381 if(!isWasmInitialized) {
9382 throw new Error("initializeWasm() must be awaited first!");
9384 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
9385 return nativeResponseValue;
9387 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
9389 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
9390 if(!isWasmInitialized) {
9391 throw new Error("initializeWasm() must be awaited first!");
9393 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
9394 return nativeResponseValue;
9396 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
9398 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
9399 if(!isWasmInitialized) {
9400 throw new Error("initializeWasm() must be awaited first!");
9402 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
9403 // debug statements here
9405 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
9407 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9408 if(!isWasmInitialized) {
9409 throw new Error("initializeWasm() must be awaited first!");
9411 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
9412 return nativeResponseValue;
9414 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
9416 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
9417 if(!isWasmInitialized) {
9418 throw new Error("initializeWasm() must be awaited first!");
9420 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
9421 return nativeResponseValue;
9423 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
9425 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
9426 if(!isWasmInitialized) {
9427 throw new Error("initializeWasm() must be awaited first!");
9429 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
9430 return nativeResponseValue;
9432 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
9434 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
9435 if(!isWasmInitialized) {
9436 throw new Error("initializeWasm() must be awaited first!");
9438 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
9439 return nativeResponseValue;
9441 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
9443 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
9444 if(!isWasmInitialized) {
9445 throw new Error("initializeWasm() must be awaited first!");
9447 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
9448 return nativeResponseValue;
9450 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
9452 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
9453 if(!isWasmInitialized) {
9454 throw new Error("initializeWasm() must be awaited first!");
9456 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
9457 // debug statements here
9459 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
9461 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9462 if(!isWasmInitialized) {
9463 throw new Error("initializeWasm() must be awaited first!");
9465 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
9466 return nativeResponseValue;
9468 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
9470 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
9471 if(!isWasmInitialized) {
9472 throw new Error("initializeWasm() must be awaited first!");
9474 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
9475 return nativeResponseValue;
9477 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
9479 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
9480 if(!isWasmInitialized) {
9481 throw new Error("initializeWasm() must be awaited first!");
9483 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
9484 return nativeResponseValue;
9486 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
9488 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
9489 if(!isWasmInitialized) {
9490 throw new Error("initializeWasm() must be awaited first!");
9492 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
9493 return nativeResponseValue;
9495 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
9497 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
9498 if(!isWasmInitialized) {
9499 throw new Error("initializeWasm() must be awaited first!");
9501 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
9502 return nativeResponseValue;
9504 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
9506 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
9507 if(!isWasmInitialized) {
9508 throw new Error("initializeWasm() must be awaited first!");
9510 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
9511 // debug statements here
9513 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
9515 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9516 if(!isWasmInitialized) {
9517 throw new Error("initializeWasm() must be awaited first!");
9519 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
9520 return nativeResponseValue;
9522 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
9524 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
9525 if(!isWasmInitialized) {
9526 throw new Error("initializeWasm() must be awaited first!");
9528 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
9529 return nativeResponseValue;
9531 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
9533 export function COption_ClosureReasonZ_some(o: bigint): bigint {
9534 if(!isWasmInitialized) {
9535 throw new Error("initializeWasm() must be awaited first!");
9537 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
9538 return nativeResponseValue;
9540 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
9542 export function COption_ClosureReasonZ_none(): bigint {
9543 if(!isWasmInitialized) {
9544 throw new Error("initializeWasm() must be awaited first!");
9546 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
9547 return nativeResponseValue;
9549 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
9551 export function COption_ClosureReasonZ_free(_res: bigint): void {
9552 if(!isWasmInitialized) {
9553 throw new Error("initializeWasm() must be awaited first!");
9555 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
9556 // debug statements here
9558 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
9560 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
9561 if(!isWasmInitialized) {
9562 throw new Error("initializeWasm() must be awaited first!");
9564 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
9565 return nativeResponseValue;
9567 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
9569 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
9570 if(!isWasmInitialized) {
9571 throw new Error("initializeWasm() must be awaited first!");
9573 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
9574 return nativeResponseValue;
9576 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
9578 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
9579 if(!isWasmInitialized) {
9580 throw new Error("initializeWasm() must be awaited first!");
9582 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
9583 return nativeResponseValue;
9585 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
9587 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
9588 if(!isWasmInitialized) {
9589 throw new Error("initializeWasm() must be awaited first!");
9591 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
9592 return nativeResponseValue;
9594 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
9596 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
9597 if(!isWasmInitialized) {
9598 throw new Error("initializeWasm() must be awaited first!");
9600 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
9601 return nativeResponseValue;
9603 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
9605 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
9606 if(!isWasmInitialized) {
9607 throw new Error("initializeWasm() must be awaited first!");
9609 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
9610 // debug statements here
9612 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
9614 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9615 if(!isWasmInitialized) {
9616 throw new Error("initializeWasm() must be awaited first!");
9618 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
9619 return nativeResponseValue;
9621 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
9623 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
9624 if(!isWasmInitialized) {
9625 throw new Error("initializeWasm() must be awaited first!");
9627 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
9628 return nativeResponseValue;
9630 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
9632 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
9633 if(!isWasmInitialized) {
9634 throw new Error("initializeWasm() must be awaited first!");
9636 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
9637 return nativeResponseValue;
9639 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
9641 export function COption_HTLCDestinationZ_none(): bigint {
9642 if(!isWasmInitialized) {
9643 throw new Error("initializeWasm() must be awaited first!");
9645 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
9646 return nativeResponseValue;
9648 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
9650 export function COption_HTLCDestinationZ_free(_res: bigint): void {
9651 if(!isWasmInitialized) {
9652 throw new Error("initializeWasm() must be awaited first!");
9654 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
9655 // debug statements here
9657 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
9659 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
9660 if(!isWasmInitialized) {
9661 throw new Error("initializeWasm() must be awaited first!");
9663 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
9664 return nativeResponseValue;
9666 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
9668 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
9669 if(!isWasmInitialized) {
9670 throw new Error("initializeWasm() must be awaited first!");
9672 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
9673 return nativeResponseValue;
9675 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
9677 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
9678 if(!isWasmInitialized) {
9679 throw new Error("initializeWasm() must be awaited first!");
9681 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
9682 return nativeResponseValue;
9684 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
9686 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
9687 if(!isWasmInitialized) {
9688 throw new Error("initializeWasm() must be awaited first!");
9690 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
9691 return nativeResponseValue;
9693 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
9695 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
9696 if(!isWasmInitialized) {
9697 throw new Error("initializeWasm() must be awaited first!");
9699 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
9700 return nativeResponseValue;
9702 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
9704 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
9705 if(!isWasmInitialized) {
9706 throw new Error("initializeWasm() must be awaited first!");
9708 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
9709 // debug statements here
9711 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
9713 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9714 if(!isWasmInitialized) {
9715 throw new Error("initializeWasm() must be awaited first!");
9717 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
9718 return nativeResponseValue;
9720 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
9722 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
9723 if(!isWasmInitialized) {
9724 throw new Error("initializeWasm() must be awaited first!");
9726 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
9727 return nativeResponseValue;
9729 // struct LDKCOption_u128Z COption_u128Z_some(struct LDKU128 o);
9731 export function COption_u128Z_some(o: number): bigint {
9732 if(!isWasmInitialized) {
9733 throw new Error("initializeWasm() must be awaited first!");
9735 const nativeResponseValue = wasm.TS_COption_u128Z_some(o);
9736 return nativeResponseValue;
9738 // struct LDKCOption_u128Z COption_u128Z_none(void);
9740 export function COption_u128Z_none(): bigint {
9741 if(!isWasmInitialized) {
9742 throw new Error("initializeWasm() must be awaited first!");
9744 const nativeResponseValue = wasm.TS_COption_u128Z_none();
9745 return nativeResponseValue;
9747 // void COption_u128Z_free(struct LDKCOption_u128Z _res);
9749 export function COption_u128Z_free(_res: bigint): void {
9750 if(!isWasmInitialized) {
9751 throw new Error("initializeWasm() must be awaited first!");
9753 const nativeResponseValue = wasm.TS_COption_u128Z_free(_res);
9754 // debug statements here
9756 // uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg);
9758 export function COption_u128Z_clone_ptr(arg: bigint): bigint {
9759 if(!isWasmInitialized) {
9760 throw new Error("initializeWasm() must be awaited first!");
9762 const nativeResponseValue = wasm.TS_COption_u128Z_clone_ptr(arg);
9763 return nativeResponseValue;
9765 // struct LDKCOption_u128Z COption_u128Z_clone(const struct LDKCOption_u128Z *NONNULL_PTR orig);
9767 export function COption_u128Z_clone(orig: bigint): bigint {
9768 if(!isWasmInitialized) {
9769 throw new Error("initializeWasm() must be awaited first!");
9771 const nativeResponseValue = wasm.TS_COption_u128Z_clone(orig);
9772 return nativeResponseValue;
9774 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
9776 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
9777 if(!isWasmInitialized) {
9778 throw new Error("initializeWasm() must be awaited first!");
9780 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
9781 return nativeResponseValue;
9783 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
9785 export function COption_NetworkUpdateZ_none(): bigint {
9786 if(!isWasmInitialized) {
9787 throw new Error("initializeWasm() must be awaited first!");
9789 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
9790 return nativeResponseValue;
9792 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
9794 export function COption_NetworkUpdateZ_free(_res: bigint): void {
9795 if(!isWasmInitialized) {
9796 throw new Error("initializeWasm() must be awaited first!");
9798 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
9799 // debug statements here
9801 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
9803 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
9804 if(!isWasmInitialized) {
9805 throw new Error("initializeWasm() must be awaited first!");
9807 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
9808 return nativeResponseValue;
9810 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
9812 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
9813 if(!isWasmInitialized) {
9814 throw new Error("initializeWasm() must be awaited first!");
9816 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
9817 return nativeResponseValue;
9819 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
9821 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
9822 if(!isWasmInitialized) {
9823 throw new Error("initializeWasm() must be awaited first!");
9825 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
9826 // debug statements here
9828 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
9830 export function COption_EventZ_some(o: bigint): bigint {
9831 if(!isWasmInitialized) {
9832 throw new Error("initializeWasm() must be awaited first!");
9834 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
9835 return nativeResponseValue;
9837 // struct LDKCOption_EventZ COption_EventZ_none(void);
9839 export function COption_EventZ_none(): bigint {
9840 if(!isWasmInitialized) {
9841 throw new Error("initializeWasm() must be awaited first!");
9843 const nativeResponseValue = wasm.TS_COption_EventZ_none();
9844 return nativeResponseValue;
9846 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
9848 export function COption_EventZ_free(_res: bigint): void {
9849 if(!isWasmInitialized) {
9850 throw new Error("initializeWasm() must be awaited first!");
9852 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
9853 // debug statements here
9855 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
9857 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
9858 if(!isWasmInitialized) {
9859 throw new Error("initializeWasm() must be awaited first!");
9861 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
9862 return nativeResponseValue;
9864 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
9866 export function COption_EventZ_clone(orig: bigint): bigint {
9867 if(!isWasmInitialized) {
9868 throw new Error("initializeWasm() must be awaited first!");
9870 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
9871 return nativeResponseValue;
9873 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
9875 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
9876 if(!isWasmInitialized) {
9877 throw new Error("initializeWasm() must be awaited first!");
9879 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
9880 return nativeResponseValue;
9882 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
9884 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
9885 if(!isWasmInitialized) {
9886 throw new Error("initializeWasm() must be awaited first!");
9888 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
9889 return nativeResponseValue;
9891 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
9893 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
9894 if(!isWasmInitialized) {
9895 throw new Error("initializeWasm() must be awaited first!");
9897 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
9898 return nativeResponseValue;
9900 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
9902 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
9903 if(!isWasmInitialized) {
9904 throw new Error("initializeWasm() must be awaited first!");
9906 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
9907 // debug statements here
9909 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
9911 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9912 if(!isWasmInitialized) {
9913 throw new Error("initializeWasm() must be awaited first!");
9915 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
9916 return nativeResponseValue;
9918 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
9920 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
9921 if(!isWasmInitialized) {
9922 throw new Error("initializeWasm() must be awaited first!");
9924 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
9925 return nativeResponseValue;
9927 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
9929 export function CVec_MessageSendEventZ_free(_res: number): void {
9930 if(!isWasmInitialized) {
9931 throw new Error("initializeWasm() must be awaited first!");
9933 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
9934 // debug statements here
9936 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
9938 export function CResult_TxOutAccessErrorZ_ok(o: bigint): bigint {
9939 if(!isWasmInitialized) {
9940 throw new Error("initializeWasm() must be awaited first!");
9942 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
9943 return nativeResponseValue;
9945 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
9947 export function CResult_TxOutAccessErrorZ_err(e: AccessError): bigint {
9948 if(!isWasmInitialized) {
9949 throw new Error("initializeWasm() must be awaited first!");
9951 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
9952 return nativeResponseValue;
9954 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
9956 export function CResult_TxOutAccessErrorZ_is_ok(o: bigint): boolean {
9957 if(!isWasmInitialized) {
9958 throw new Error("initializeWasm() must be awaited first!");
9960 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
9961 return nativeResponseValue;
9963 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
9965 export function CResult_TxOutAccessErrorZ_free(_res: bigint): void {
9966 if(!isWasmInitialized) {
9967 throw new Error("initializeWasm() must be awaited first!");
9969 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
9970 // debug statements here
9972 // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
9974 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: bigint): bigint {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
9979 return nativeResponseValue;
9981 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
9983 export function CResult_TxOutAccessErrorZ_clone(orig: bigint): bigint {
9984 if(!isWasmInitialized) {
9985 throw new Error("initializeWasm() must be awaited first!");
9987 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
9988 return nativeResponseValue;
9990 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
9992 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
9993 if(!isWasmInitialized) {
9994 throw new Error("initializeWasm() must be awaited first!");
9996 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
9997 return nativeResponseValue;
9999 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
10001 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
10002 if(!isWasmInitialized) {
10003 throw new Error("initializeWasm() must be awaited first!");
10005 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
10006 return nativeResponseValue;
10008 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
10010 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
10011 if(!isWasmInitialized) {
10012 throw new Error("initializeWasm() must be awaited first!");
10014 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
10015 return nativeResponseValue;
10017 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
10019 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
10020 if(!isWasmInitialized) {
10021 throw new Error("initializeWasm() must be awaited first!");
10023 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
10024 // debug statements here
10026 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
10028 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
10029 if(!isWasmInitialized) {
10030 throw new Error("initializeWasm() must be awaited first!");
10032 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
10033 // debug statements here
10035 // uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg);
10037 export function C2Tuple_TxidBlockHashZ_clone_ptr(arg: bigint): bigint {
10038 if(!isWasmInitialized) {
10039 throw new Error("initializeWasm() must be awaited first!");
10041 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone_ptr(arg);
10042 return nativeResponseValue;
10044 // struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_clone(const struct LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR orig);
10046 export function C2Tuple_TxidBlockHashZ_clone(orig: bigint): bigint {
10047 if(!isWasmInitialized) {
10048 throw new Error("initializeWasm() must be awaited first!");
10050 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone(orig);
10051 return nativeResponseValue;
10053 // struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10055 export function C2Tuple_TxidBlockHashZ_new(a: number, b: number): bigint {
10056 if(!isWasmInitialized) {
10057 throw new Error("initializeWasm() must be awaited first!");
10059 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_new(a, b);
10060 return nativeResponseValue;
10062 // void C2Tuple_TxidBlockHashZ_free(struct LDKC2Tuple_TxidBlockHashZ _res);
10064 export function C2Tuple_TxidBlockHashZ_free(_res: bigint): void {
10065 if(!isWasmInitialized) {
10066 throw new Error("initializeWasm() must be awaited first!");
10068 const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_free(_res);
10069 // debug statements here
10071 // void CVec_C2Tuple_TxidBlockHashZZ_free(struct LDKCVec_C2Tuple_TxidBlockHashZZ _res);
10073 export function CVec_C2Tuple_TxidBlockHashZZ_free(_res: number): void {
10074 if(!isWasmInitialized) {
10075 throw new Error("initializeWasm() must be awaited first!");
10077 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidBlockHashZZ_free(_res);
10078 // debug statements here
10080 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
10082 export function CVec_MonitorEventZ_free(_res: number): void {
10083 if(!isWasmInitialized) {
10084 throw new Error("initializeWasm() must be awaited first!");
10086 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
10087 // debug statements here
10089 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
10091 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
10092 if(!isWasmInitialized) {
10093 throw new Error("initializeWasm() must be awaited first!");
10095 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
10096 return nativeResponseValue;
10098 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
10100 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
10101 if(!isWasmInitialized) {
10102 throw new Error("initializeWasm() must be awaited first!");
10104 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
10105 return nativeResponseValue;
10107 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
10109 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
10110 if(!isWasmInitialized) {
10111 throw new Error("initializeWasm() must be awaited first!");
10113 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
10114 return nativeResponseValue;
10116 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
10118 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
10119 if(!isWasmInitialized) {
10120 throw new Error("initializeWasm() must be awaited first!");
10122 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
10123 // debug statements here
10125 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
10127 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
10128 if(!isWasmInitialized) {
10129 throw new Error("initializeWasm() must be awaited first!");
10131 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
10132 // debug statements here
10134 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
10136 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
10137 if(!isWasmInitialized) {
10138 throw new Error("initializeWasm() must be awaited first!");
10140 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
10141 return nativeResponseValue;
10143 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
10145 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
10146 if(!isWasmInitialized) {
10147 throw new Error("initializeWasm() must be awaited first!");
10149 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
10150 return nativeResponseValue;
10152 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
10154 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
10155 if(!isWasmInitialized) {
10156 throw new Error("initializeWasm() must be awaited first!");
10158 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
10159 return nativeResponseValue;
10161 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
10163 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
10164 if(!isWasmInitialized) {
10165 throw new Error("initializeWasm() must be awaited first!");
10167 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
10168 // debug statements here
10170 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
10172 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10173 if(!isWasmInitialized) {
10174 throw new Error("initializeWasm() must be awaited first!");
10176 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
10177 return nativeResponseValue;
10179 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
10181 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
10182 if(!isWasmInitialized) {
10183 throw new Error("initializeWasm() must be awaited first!");
10185 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
10186 return nativeResponseValue;
10188 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
10190 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
10191 if(!isWasmInitialized) {
10192 throw new Error("initializeWasm() must be awaited first!");
10194 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
10195 return nativeResponseValue;
10197 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
10199 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
10200 if(!isWasmInitialized) {
10201 throw new Error("initializeWasm() must be awaited first!");
10203 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
10204 return nativeResponseValue;
10206 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
10208 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
10209 if(!isWasmInitialized) {
10210 throw new Error("initializeWasm() must be awaited first!");
10212 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
10213 return nativeResponseValue;
10215 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
10217 export function C2Tuple_u64u64Z_free(_res: bigint): void {
10218 if(!isWasmInitialized) {
10219 throw new Error("initializeWasm() must be awaited first!");
10221 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
10222 // debug statements here
10224 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
10226 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
10227 if(!isWasmInitialized) {
10228 throw new Error("initializeWasm() must be awaited first!");
10230 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
10231 return nativeResponseValue;
10233 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
10235 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
10236 if(!isWasmInitialized) {
10237 throw new Error("initializeWasm() must be awaited first!");
10239 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
10240 return nativeResponseValue;
10242 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
10244 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
10245 if(!isWasmInitialized) {
10246 throw new Error("initializeWasm() must be awaited first!");
10248 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
10249 // debug statements here
10251 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
10253 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
10254 if(!isWasmInitialized) {
10255 throw new Error("initializeWasm() must be awaited first!");
10257 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
10258 return nativeResponseValue;
10260 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
10262 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
10263 if(!isWasmInitialized) {
10264 throw new Error("initializeWasm() must be awaited first!");
10266 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
10267 return nativeResponseValue;
10269 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
10271 export function CVec_NodeIdZ_free(_res: number): void {
10272 if(!isWasmInitialized) {
10273 throw new Error("initializeWasm() must be awaited first!");
10275 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
10276 // debug statements here
10278 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
10280 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
10281 if(!isWasmInitialized) {
10282 throw new Error("initializeWasm() must be awaited first!");
10284 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
10285 return nativeResponseValue;
10287 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
10289 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
10290 if(!isWasmInitialized) {
10291 throw new Error("initializeWasm() must be awaited first!");
10293 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
10294 return nativeResponseValue;
10296 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
10298 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
10299 if(!isWasmInitialized) {
10300 throw new Error("initializeWasm() must be awaited first!");
10302 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
10303 return nativeResponseValue;
10305 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
10307 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
10308 if(!isWasmInitialized) {
10309 throw new Error("initializeWasm() must be awaited first!");
10311 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
10312 // debug statements here
10314 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
10316 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10317 if(!isWasmInitialized) {
10318 throw new Error("initializeWasm() must be awaited first!");
10320 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
10321 return nativeResponseValue;
10323 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10325 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
10326 if(!isWasmInitialized) {
10327 throw new Error("initializeWasm() must be awaited first!");
10329 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
10330 return nativeResponseValue;
10332 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
10334 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10335 if(!isWasmInitialized) {
10336 throw new Error("initializeWasm() must be awaited first!");
10338 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
10339 return nativeResponseValue;
10341 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
10343 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
10344 if(!isWasmInitialized) {
10345 throw new Error("initializeWasm() must be awaited first!");
10347 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
10348 // debug statements here
10350 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
10352 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10353 if(!isWasmInitialized) {
10354 throw new Error("initializeWasm() must be awaited first!");
10356 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
10357 return nativeResponseValue;
10359 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
10361 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10362 if(!isWasmInitialized) {
10363 throw new Error("initializeWasm() must be awaited first!");
10365 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
10366 return nativeResponseValue;
10368 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
10370 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10371 if(!isWasmInitialized) {
10372 throw new Error("initializeWasm() must be awaited first!");
10374 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
10375 return nativeResponseValue;
10377 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10379 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
10380 if(!isWasmInitialized) {
10381 throw new Error("initializeWasm() must be awaited first!");
10383 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
10384 return nativeResponseValue;
10386 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
10388 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10389 if(!isWasmInitialized) {
10390 throw new Error("initializeWasm() must be awaited first!");
10392 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
10393 return nativeResponseValue;
10395 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
10397 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
10398 if(!isWasmInitialized) {
10399 throw new Error("initializeWasm() must be awaited first!");
10401 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
10402 // debug statements here
10404 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
10406 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10407 if(!isWasmInitialized) {
10408 throw new Error("initializeWasm() must be awaited first!");
10410 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
10411 return nativeResponseValue;
10413 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
10415 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10416 if(!isWasmInitialized) {
10417 throw new Error("initializeWasm() must be awaited first!");
10419 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
10420 return nativeResponseValue;
10422 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
10424 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10425 if(!isWasmInitialized) {
10426 throw new Error("initializeWasm() must be awaited first!");
10428 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
10429 return nativeResponseValue;
10431 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10433 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10434 if(!isWasmInitialized) {
10435 throw new Error("initializeWasm() must be awaited first!");
10437 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
10438 return nativeResponseValue;
10440 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
10442 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10443 if(!isWasmInitialized) {
10444 throw new Error("initializeWasm() must be awaited first!");
10446 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
10447 return nativeResponseValue;
10449 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
10451 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
10452 if(!isWasmInitialized) {
10453 throw new Error("initializeWasm() must be awaited first!");
10455 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
10456 // debug statements here
10458 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10460 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10461 if(!isWasmInitialized) {
10462 throw new Error("initializeWasm() must be awaited first!");
10464 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
10465 return nativeResponseValue;
10467 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10469 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10470 if(!isWasmInitialized) {
10471 throw new Error("initializeWasm() must be awaited first!");
10473 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
10474 return nativeResponseValue;
10476 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
10478 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10479 if(!isWasmInitialized) {
10480 throw new Error("initializeWasm() must be awaited first!");
10482 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
10483 return nativeResponseValue;
10485 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10487 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
10488 if(!isWasmInitialized) {
10489 throw new Error("initializeWasm() must be awaited first!");
10491 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
10492 return nativeResponseValue;
10494 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
10496 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10497 if(!isWasmInitialized) {
10498 throw new Error("initializeWasm() must be awaited first!");
10500 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
10501 return nativeResponseValue;
10503 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
10505 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
10506 if(!isWasmInitialized) {
10507 throw new Error("initializeWasm() must be awaited first!");
10509 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
10510 // debug statements here
10512 // uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
10514 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10515 if(!isWasmInitialized) {
10516 throw new Error("initializeWasm() must be awaited first!");
10518 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
10519 return nativeResponseValue;
10521 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
10523 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10524 if(!isWasmInitialized) {
10525 throw new Error("initializeWasm() must be awaited first!");
10527 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
10528 return nativeResponseValue;
10530 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
10532 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10533 if(!isWasmInitialized) {
10534 throw new Error("initializeWasm() must be awaited first!");
10536 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
10537 return nativeResponseValue;
10539 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10541 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
10542 if(!isWasmInitialized) {
10543 throw new Error("initializeWasm() must be awaited first!");
10545 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
10546 return nativeResponseValue;
10548 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
10550 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10551 if(!isWasmInitialized) {
10552 throw new Error("initializeWasm() must be awaited first!");
10554 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
10555 return nativeResponseValue;
10557 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
10559 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
10560 if(!isWasmInitialized) {
10561 throw new Error("initializeWasm() must be awaited first!");
10563 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
10564 // debug statements here
10566 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
10568 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10569 if(!isWasmInitialized) {
10570 throw new Error("initializeWasm() must be awaited first!");
10572 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
10573 return nativeResponseValue;
10575 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
10577 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10578 if(!isWasmInitialized) {
10579 throw new Error("initializeWasm() must be awaited first!");
10581 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
10582 return nativeResponseValue;
10584 // struct LDKCResult_OfferFeaturesDecodeErrorZ CResult_OfferFeaturesDecodeErrorZ_ok(struct LDKOfferFeatures o);
10586 export function CResult_OfferFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10587 if(!isWasmInitialized) {
10588 throw new Error("initializeWasm() must be awaited first!");
10590 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_ok(o);
10591 return nativeResponseValue;
10593 // struct LDKCResult_OfferFeaturesDecodeErrorZ CResult_OfferFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10595 export function CResult_OfferFeaturesDecodeErrorZ_err(e: bigint): bigint {
10596 if(!isWasmInitialized) {
10597 throw new Error("initializeWasm() must be awaited first!");
10599 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_err(e);
10600 return nativeResponseValue;
10602 // bool CResult_OfferFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR o);
10604 export function CResult_OfferFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10605 if(!isWasmInitialized) {
10606 throw new Error("initializeWasm() must be awaited first!");
10608 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_is_ok(o);
10609 return nativeResponseValue;
10611 // void CResult_OfferFeaturesDecodeErrorZ_free(struct LDKCResult_OfferFeaturesDecodeErrorZ _res);
10613 export function CResult_OfferFeaturesDecodeErrorZ_free(_res: bigint): void {
10614 if(!isWasmInitialized) {
10615 throw new Error("initializeWasm() must be awaited first!");
10617 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_free(_res);
10618 // debug statements here
10620 // uint64_t CResult_OfferFeaturesDecodeErrorZ_clone_ptr(LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR arg);
10622 export function CResult_OfferFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10623 if(!isWasmInitialized) {
10624 throw new Error("initializeWasm() must be awaited first!");
10626 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_clone_ptr(arg);
10627 return nativeResponseValue;
10629 // struct LDKCResult_OfferFeaturesDecodeErrorZ CResult_OfferFeaturesDecodeErrorZ_clone(const struct LDKCResult_OfferFeaturesDecodeErrorZ *NONNULL_PTR orig);
10631 export function CResult_OfferFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10632 if(!isWasmInitialized) {
10633 throw new Error("initializeWasm() must be awaited first!");
10635 const nativeResponseValue = wasm.TS_CResult_OfferFeaturesDecodeErrorZ_clone(orig);
10636 return nativeResponseValue;
10638 // struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ CResult_InvoiceRequestFeaturesDecodeErrorZ_ok(struct LDKInvoiceRequestFeatures o);
10640 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_ok(o: bigint): bigint {
10641 if(!isWasmInitialized) {
10642 throw new Error("initializeWasm() must be awaited first!");
10644 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_ok(o);
10645 return nativeResponseValue;
10647 // struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ CResult_InvoiceRequestFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
10649 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_err(e: bigint): bigint {
10650 if(!isWasmInitialized) {
10651 throw new Error("initializeWasm() must be awaited first!");
10653 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_err(e);
10654 return nativeResponseValue;
10656 // bool CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR o);
10658 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
10659 if(!isWasmInitialized) {
10660 throw new Error("initializeWasm() must be awaited first!");
10662 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_is_ok(o);
10663 return nativeResponseValue;
10665 // void CResult_InvoiceRequestFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ _res);
10667 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_free(_res: bigint): void {
10668 if(!isWasmInitialized) {
10669 throw new Error("initializeWasm() must be awaited first!");
10671 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_free(_res);
10672 // debug statements here
10674 // uint64_t CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR arg);
10676 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10677 if(!isWasmInitialized) {
10678 throw new Error("initializeWasm() must be awaited first!");
10680 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone_ptr(arg);
10681 return nativeResponseValue;
10683 // struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ *NONNULL_PTR orig);
10685 export function CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
10686 if(!isWasmInitialized) {
10687 throw new Error("initializeWasm() must be awaited first!");
10689 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFeaturesDecodeErrorZ_clone(orig);
10690 return nativeResponseValue;
10692 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
10694 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
10695 if(!isWasmInitialized) {
10696 throw new Error("initializeWasm() must be awaited first!");
10698 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
10699 return nativeResponseValue;
10701 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
10703 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
10704 if(!isWasmInitialized) {
10705 throw new Error("initializeWasm() must be awaited first!");
10707 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
10708 return nativeResponseValue;
10710 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
10712 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
10713 if(!isWasmInitialized) {
10714 throw new Error("initializeWasm() must be awaited first!");
10716 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
10717 return nativeResponseValue;
10719 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
10721 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
10722 if(!isWasmInitialized) {
10723 throw new Error("initializeWasm() must be awaited first!");
10725 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
10726 // debug statements here
10728 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
10730 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10731 if(!isWasmInitialized) {
10732 throw new Error("initializeWasm() must be awaited first!");
10734 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
10735 return nativeResponseValue;
10737 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
10739 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
10740 if(!isWasmInitialized) {
10741 throw new Error("initializeWasm() must be awaited first!");
10743 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
10744 return nativeResponseValue;
10746 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
10748 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
10749 if(!isWasmInitialized) {
10750 throw new Error("initializeWasm() must be awaited first!");
10752 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
10753 return nativeResponseValue;
10755 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
10757 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
10758 if(!isWasmInitialized) {
10759 throw new Error("initializeWasm() must be awaited first!");
10761 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
10762 return nativeResponseValue;
10764 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
10766 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
10767 if(!isWasmInitialized) {
10768 throw new Error("initializeWasm() must be awaited first!");
10770 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
10771 return nativeResponseValue;
10773 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
10775 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
10776 if(!isWasmInitialized) {
10777 throw new Error("initializeWasm() must be awaited first!");
10779 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
10780 // debug statements here
10782 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
10784 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10785 if(!isWasmInitialized) {
10786 throw new Error("initializeWasm() must be awaited first!");
10788 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
10789 return nativeResponseValue;
10791 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
10793 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
10794 if(!isWasmInitialized) {
10795 throw new Error("initializeWasm() must be awaited first!");
10797 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
10798 return nativeResponseValue;
10800 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
10802 export function COption_AccessZ_some(o: bigint): bigint {
10803 if(!isWasmInitialized) {
10804 throw new Error("initializeWasm() must be awaited first!");
10806 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
10807 return nativeResponseValue;
10809 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
10811 export function COption_AccessZ_none(): bigint {
10812 if(!isWasmInitialized) {
10813 throw new Error("initializeWasm() must be awaited first!");
10815 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
10816 return nativeResponseValue;
10818 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
10820 export function COption_AccessZ_free(_res: bigint): void {
10821 if(!isWasmInitialized) {
10822 throw new Error("initializeWasm() must be awaited first!");
10824 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
10825 // debug statements here
10827 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
10829 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
10830 if(!isWasmInitialized) {
10831 throw new Error("initializeWasm() must be awaited first!");
10833 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
10834 return nativeResponseValue;
10836 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
10838 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
10839 if(!isWasmInitialized) {
10840 throw new Error("initializeWasm() must be awaited first!");
10842 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
10843 return nativeResponseValue;
10845 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
10847 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
10848 if(!isWasmInitialized) {
10849 throw new Error("initializeWasm() must be awaited first!");
10851 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
10852 return nativeResponseValue;
10854 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
10856 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
10857 if(!isWasmInitialized) {
10858 throw new Error("initializeWasm() must be awaited first!");
10860 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
10861 // debug statements here
10863 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
10865 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
10866 if(!isWasmInitialized) {
10867 throw new Error("initializeWasm() must be awaited first!");
10869 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
10870 return nativeResponseValue;
10872 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
10874 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
10875 if(!isWasmInitialized) {
10876 throw new Error("initializeWasm() must be awaited first!");
10878 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
10879 return nativeResponseValue;
10881 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
10883 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
10884 if(!isWasmInitialized) {
10885 throw new Error("initializeWasm() must be awaited first!");
10887 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
10888 return nativeResponseValue;
10890 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
10892 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
10893 if(!isWasmInitialized) {
10894 throw new Error("initializeWasm() must be awaited first!");
10896 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
10897 return nativeResponseValue;
10899 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
10901 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
10902 if(!isWasmInitialized) {
10903 throw new Error("initializeWasm() must be awaited first!");
10905 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
10906 return nativeResponseValue;
10908 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
10910 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
10911 if(!isWasmInitialized) {
10912 throw new Error("initializeWasm() must be awaited first!");
10914 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
10915 // debug statements here
10917 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
10919 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
10920 if(!isWasmInitialized) {
10921 throw new Error("initializeWasm() must be awaited first!");
10923 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
10924 return nativeResponseValue;
10926 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
10928 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
10929 if(!isWasmInitialized) {
10930 throw new Error("initializeWasm() must be awaited first!");
10932 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
10933 return nativeResponseValue;
10935 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
10937 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
10938 if(!isWasmInitialized) {
10939 throw new Error("initializeWasm() must be awaited first!");
10941 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
10942 // debug statements here
10944 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
10946 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
10947 if(!isWasmInitialized) {
10948 throw new Error("initializeWasm() must be awaited first!");
10950 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
10951 return nativeResponseValue;
10953 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
10955 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
10956 if(!isWasmInitialized) {
10957 throw new Error("initializeWasm() must be awaited first!");
10959 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
10960 return nativeResponseValue;
10962 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
10964 export function CResult_NoneLightningErrorZ_ok(): bigint {
10965 if(!isWasmInitialized) {
10966 throw new Error("initializeWasm() must be awaited first!");
10968 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
10969 return nativeResponseValue;
10971 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
10973 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
10974 if(!isWasmInitialized) {
10975 throw new Error("initializeWasm() must be awaited first!");
10977 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
10978 return nativeResponseValue;
10980 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
10982 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
10983 if(!isWasmInitialized) {
10984 throw new Error("initializeWasm() must be awaited first!");
10986 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
10987 return nativeResponseValue;
10989 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
10991 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
10992 if(!isWasmInitialized) {
10993 throw new Error("initializeWasm() must be awaited first!");
10995 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
10996 // debug statements here
10998 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
11000 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
11001 if(!isWasmInitialized) {
11002 throw new Error("initializeWasm() must be awaited first!");
11004 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
11005 return nativeResponseValue;
11007 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
11009 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
11010 if(!isWasmInitialized) {
11011 throw new Error("initializeWasm() must be awaited first!");
11013 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
11014 return nativeResponseValue;
11016 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
11018 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
11019 if(!isWasmInitialized) {
11020 throw new Error("initializeWasm() must be awaited first!");
11022 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
11023 return nativeResponseValue;
11025 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
11027 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
11028 if(!isWasmInitialized) {
11029 throw new Error("initializeWasm() must be awaited first!");
11031 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
11032 return nativeResponseValue;
11034 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
11036 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11037 if(!isWasmInitialized) {
11038 throw new Error("initializeWasm() must be awaited first!");
11040 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
11041 return nativeResponseValue;
11043 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
11045 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
11046 if(!isWasmInitialized) {
11047 throw new Error("initializeWasm() must be awaited first!");
11049 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
11050 // debug statements here
11052 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
11054 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11055 if(!isWasmInitialized) {
11056 throw new Error("initializeWasm() must be awaited first!");
11058 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
11059 return nativeResponseValue;
11061 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
11063 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
11064 if(!isWasmInitialized) {
11065 throw new Error("initializeWasm() must be awaited first!");
11067 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
11068 return nativeResponseValue;
11070 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
11072 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
11073 if(!isWasmInitialized) {
11074 throw new Error("initializeWasm() must be awaited first!");
11076 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
11077 return nativeResponseValue;
11079 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
11081 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
11082 if(!isWasmInitialized) {
11083 throw new Error("initializeWasm() must be awaited first!");
11085 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
11086 return nativeResponseValue;
11088 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
11090 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11091 if(!isWasmInitialized) {
11092 throw new Error("initializeWasm() must be awaited first!");
11094 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
11095 return nativeResponseValue;
11097 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
11099 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
11100 if(!isWasmInitialized) {
11101 throw new Error("initializeWasm() must be awaited first!");
11103 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
11104 // debug statements here
11106 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
11108 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11109 if(!isWasmInitialized) {
11110 throw new Error("initializeWasm() must be awaited first!");
11112 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
11113 return nativeResponseValue;
11115 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
11117 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
11118 if(!isWasmInitialized) {
11119 throw new Error("initializeWasm() must be awaited first!");
11121 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
11122 return nativeResponseValue;
11124 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
11126 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
11127 if(!isWasmInitialized) {
11128 throw new Error("initializeWasm() must be awaited first!");
11130 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
11131 return nativeResponseValue;
11133 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
11135 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
11136 if(!isWasmInitialized) {
11137 throw new Error("initializeWasm() must be awaited first!");
11139 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
11140 return nativeResponseValue;
11142 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
11144 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
11145 if(!isWasmInitialized) {
11146 throw new Error("initializeWasm() must be awaited first!");
11148 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
11149 return nativeResponseValue;
11151 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
11153 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
11154 if(!isWasmInitialized) {
11155 throw new Error("initializeWasm() must be awaited first!");
11157 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
11158 // debug statements here
11160 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
11162 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11163 if(!isWasmInitialized) {
11164 throw new Error("initializeWasm() must be awaited first!");
11166 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
11167 return nativeResponseValue;
11169 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
11171 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
11172 if(!isWasmInitialized) {
11173 throw new Error("initializeWasm() must be awaited first!");
11175 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
11176 return nativeResponseValue;
11178 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
11180 export function CVec_NetAddressZ_free(_res: number): void {
11181 if(!isWasmInitialized) {
11182 throw new Error("initializeWasm() must be awaited first!");
11184 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
11185 // debug statements here
11187 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
11189 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
11190 if(!isWasmInitialized) {
11191 throw new Error("initializeWasm() must be awaited first!");
11193 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
11194 return nativeResponseValue;
11196 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
11198 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
11199 if(!isWasmInitialized) {
11200 throw new Error("initializeWasm() must be awaited first!");
11202 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
11203 return nativeResponseValue;
11205 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
11207 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11208 if(!isWasmInitialized) {
11209 throw new Error("initializeWasm() must be awaited first!");
11211 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
11212 return nativeResponseValue;
11214 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
11216 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
11217 if(!isWasmInitialized) {
11218 throw new Error("initializeWasm() must be awaited first!");
11220 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
11221 // debug statements here
11223 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
11225 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11226 if(!isWasmInitialized) {
11227 throw new Error("initializeWasm() must be awaited first!");
11229 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
11230 return nativeResponseValue;
11232 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
11234 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
11235 if(!isWasmInitialized) {
11236 throw new Error("initializeWasm() must be awaited first!");
11238 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
11239 return nativeResponseValue;
11241 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
11243 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
11244 if(!isWasmInitialized) {
11245 throw new Error("initializeWasm() must be awaited first!");
11247 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
11248 return nativeResponseValue;
11250 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
11252 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
11253 if(!isWasmInitialized) {
11254 throw new Error("initializeWasm() must be awaited first!");
11256 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
11257 return nativeResponseValue;
11259 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
11261 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
11262 if(!isWasmInitialized) {
11263 throw new Error("initializeWasm() must be awaited first!");
11265 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
11266 return nativeResponseValue;
11268 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
11270 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
11271 if(!isWasmInitialized) {
11272 throw new Error("initializeWasm() must be awaited first!");
11274 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
11275 // debug statements here
11277 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
11279 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11280 if(!isWasmInitialized) {
11281 throw new Error("initializeWasm() must be awaited first!");
11283 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
11284 return nativeResponseValue;
11286 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
11288 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
11289 if(!isWasmInitialized) {
11290 throw new Error("initializeWasm() must be awaited first!");
11292 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
11293 return nativeResponseValue;
11295 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
11297 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
11298 if(!isWasmInitialized) {
11299 throw new Error("initializeWasm() must be awaited first!");
11301 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
11302 return nativeResponseValue;
11304 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
11306 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
11307 if(!isWasmInitialized) {
11308 throw new Error("initializeWasm() must be awaited first!");
11310 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
11311 return nativeResponseValue;
11313 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
11315 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11316 if(!isWasmInitialized) {
11317 throw new Error("initializeWasm() must be awaited first!");
11319 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
11320 return nativeResponseValue;
11322 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
11324 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
11325 if(!isWasmInitialized) {
11326 throw new Error("initializeWasm() must be awaited first!");
11328 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
11329 // debug statements here
11331 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
11333 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11334 if(!isWasmInitialized) {
11335 throw new Error("initializeWasm() must be awaited first!");
11337 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
11338 return nativeResponseValue;
11340 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
11342 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
11343 if(!isWasmInitialized) {
11344 throw new Error("initializeWasm() must be awaited first!");
11346 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
11347 return nativeResponseValue;
11349 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
11351 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
11352 if(!isWasmInitialized) {
11353 throw new Error("initializeWasm() must be awaited first!");
11355 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
11356 return nativeResponseValue;
11358 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
11360 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
11361 if(!isWasmInitialized) {
11362 throw new Error("initializeWasm() must be awaited first!");
11364 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
11365 return nativeResponseValue;
11367 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
11369 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
11370 if(!isWasmInitialized) {
11371 throw new Error("initializeWasm() must be awaited first!");
11373 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
11374 return nativeResponseValue;
11376 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
11378 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
11379 if(!isWasmInitialized) {
11380 throw new Error("initializeWasm() must be awaited first!");
11382 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
11383 // debug statements here
11385 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
11387 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
11388 if(!isWasmInitialized) {
11389 throw new Error("initializeWasm() must be awaited first!");
11391 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
11392 return nativeResponseValue;
11394 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
11396 export function COption_CVec_NetAddressZZ_none(): bigint {
11397 if(!isWasmInitialized) {
11398 throw new Error("initializeWasm() must be awaited first!");
11400 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
11401 return nativeResponseValue;
11403 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
11405 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
11406 if(!isWasmInitialized) {
11407 throw new Error("initializeWasm() must be awaited first!");
11409 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
11410 // debug statements here
11412 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
11414 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
11415 if(!isWasmInitialized) {
11416 throw new Error("initializeWasm() must be awaited first!");
11418 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
11419 return nativeResponseValue;
11421 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
11423 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
11424 if(!isWasmInitialized) {
11425 throw new Error("initializeWasm() must be awaited first!");
11427 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
11428 return nativeResponseValue;
11430 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
11432 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11433 if(!isWasmInitialized) {
11434 throw new Error("initializeWasm() must be awaited first!");
11436 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
11437 return nativeResponseValue;
11439 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11441 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11442 if(!isWasmInitialized) {
11443 throw new Error("initializeWasm() must be awaited first!");
11445 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
11446 return nativeResponseValue;
11448 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11450 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11451 if(!isWasmInitialized) {
11452 throw new Error("initializeWasm() must be awaited first!");
11454 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11455 return nativeResponseValue;
11457 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
11459 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11460 if(!isWasmInitialized) {
11461 throw new Error("initializeWasm() must be awaited first!");
11463 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
11464 // debug statements here
11466 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11468 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11469 if(!isWasmInitialized) {
11470 throw new Error("initializeWasm() must be awaited first!");
11472 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11473 return nativeResponseValue;
11475 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11477 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11478 if(!isWasmInitialized) {
11479 throw new Error("initializeWasm() must be awaited first!");
11481 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11482 return nativeResponseValue;
11484 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
11486 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11487 if(!isWasmInitialized) {
11488 throw new Error("initializeWasm() must be awaited first!");
11490 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
11491 return nativeResponseValue;
11493 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11495 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11496 if(!isWasmInitialized) {
11497 throw new Error("initializeWasm() must be awaited first!");
11499 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11500 return nativeResponseValue;
11502 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11504 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11505 if(!isWasmInitialized) {
11506 throw new Error("initializeWasm() must be awaited first!");
11508 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11509 return nativeResponseValue;
11511 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11513 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11514 if(!isWasmInitialized) {
11515 throw new Error("initializeWasm() must be awaited first!");
11517 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11518 // debug statements here
11520 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11522 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11523 if(!isWasmInitialized) {
11524 throw new Error("initializeWasm() must be awaited first!");
11526 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11527 return nativeResponseValue;
11529 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11531 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11532 if(!isWasmInitialized) {
11533 throw new Error("initializeWasm() must be awaited first!");
11535 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11536 return nativeResponseValue;
11538 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
11540 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11541 if(!isWasmInitialized) {
11542 throw new Error("initializeWasm() must be awaited first!");
11544 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
11545 return nativeResponseValue;
11547 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11549 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11550 if(!isWasmInitialized) {
11551 throw new Error("initializeWasm() must be awaited first!");
11553 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
11554 return nativeResponseValue;
11556 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11558 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11559 if(!isWasmInitialized) {
11560 throw new Error("initializeWasm() must be awaited first!");
11562 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
11563 return nativeResponseValue;
11565 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
11567 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11568 if(!isWasmInitialized) {
11569 throw new Error("initializeWasm() must be awaited first!");
11571 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
11572 // debug statements here
11574 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11576 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11577 if(!isWasmInitialized) {
11578 throw new Error("initializeWasm() must be awaited first!");
11580 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11581 return nativeResponseValue;
11583 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11585 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11586 if(!isWasmInitialized) {
11587 throw new Error("initializeWasm() must be awaited first!");
11589 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11590 return nativeResponseValue;
11592 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
11594 export function CVec_PaymentPreimageZ_free(_res: number): void {
11595 if(!isWasmInitialized) {
11596 throw new Error("initializeWasm() must be awaited first!");
11598 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
11599 // debug statements here
11601 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
11603 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
11604 if(!isWasmInitialized) {
11605 throw new Error("initializeWasm() must be awaited first!");
11607 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
11608 return nativeResponseValue;
11610 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
11612 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
11613 if(!isWasmInitialized) {
11614 throw new Error("initializeWasm() must be awaited first!");
11616 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
11617 return nativeResponseValue;
11619 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
11621 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
11622 if(!isWasmInitialized) {
11623 throw new Error("initializeWasm() must be awaited first!");
11625 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
11626 return nativeResponseValue;
11628 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
11630 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
11631 if(!isWasmInitialized) {
11632 throw new Error("initializeWasm() must be awaited first!");
11634 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
11635 // debug statements here
11637 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
11639 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
11640 if(!isWasmInitialized) {
11641 throw new Error("initializeWasm() must be awaited first!");
11643 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
11644 return nativeResponseValue;
11646 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
11648 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
11649 if(!isWasmInitialized) {
11650 throw new Error("initializeWasm() must be awaited first!");
11652 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
11653 return nativeResponseValue;
11655 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
11657 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
11658 if(!isWasmInitialized) {
11659 throw new Error("initializeWasm() must be awaited first!");
11661 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
11662 return nativeResponseValue;
11664 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
11666 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
11667 if(!isWasmInitialized) {
11668 throw new Error("initializeWasm() must be awaited first!");
11670 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
11671 // debug statements here
11673 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
11675 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
11676 if(!isWasmInitialized) {
11677 throw new Error("initializeWasm() must be awaited first!");
11679 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
11680 return nativeResponseValue;
11682 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
11684 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
11685 if(!isWasmInitialized) {
11686 throw new Error("initializeWasm() must be awaited first!");
11688 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
11689 return nativeResponseValue;
11691 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
11693 export function CResult_SignatureNoneZ_ok(o: number): bigint {
11694 if(!isWasmInitialized) {
11695 throw new Error("initializeWasm() must be awaited first!");
11697 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
11698 return nativeResponseValue;
11700 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
11702 export function CResult_SignatureNoneZ_err(): bigint {
11703 if(!isWasmInitialized) {
11704 throw new Error("initializeWasm() must be awaited first!");
11706 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
11707 return nativeResponseValue;
11709 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
11711 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
11712 if(!isWasmInitialized) {
11713 throw new Error("initializeWasm() must be awaited first!");
11715 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
11716 return nativeResponseValue;
11718 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
11720 export function CResult_SignatureNoneZ_free(_res: bigint): void {
11721 if(!isWasmInitialized) {
11722 throw new Error("initializeWasm() must be awaited first!");
11724 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
11725 // debug statements here
11727 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
11729 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
11730 if(!isWasmInitialized) {
11731 throw new Error("initializeWasm() must be awaited first!");
11733 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
11734 return nativeResponseValue;
11736 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
11738 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
11739 if(!isWasmInitialized) {
11740 throw new Error("initializeWasm() must be awaited first!");
11742 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
11743 return nativeResponseValue;
11745 // uint64_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
11747 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: bigint): bigint {
11748 if(!isWasmInitialized) {
11749 throw new Error("initializeWasm() must be awaited first!");
11751 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
11752 return nativeResponseValue;
11754 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
11756 export function C2Tuple_SignatureSignatureZ_clone(orig: bigint): bigint {
11757 if(!isWasmInitialized) {
11758 throw new Error("initializeWasm() must be awaited first!");
11760 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
11761 return nativeResponseValue;
11763 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
11765 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): bigint {
11766 if(!isWasmInitialized) {
11767 throw new Error("initializeWasm() must be awaited first!");
11769 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
11770 return nativeResponseValue;
11772 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
11774 export function C2Tuple_SignatureSignatureZ_free(_res: bigint): void {
11775 if(!isWasmInitialized) {
11776 throw new Error("initializeWasm() must be awaited first!");
11778 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
11779 // debug statements here
11781 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
11783 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: bigint): bigint {
11784 if(!isWasmInitialized) {
11785 throw new Error("initializeWasm() must be awaited first!");
11787 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
11788 return nativeResponseValue;
11790 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
11792 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): bigint {
11793 if(!isWasmInitialized) {
11794 throw new Error("initializeWasm() must be awaited first!");
11796 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
11797 return nativeResponseValue;
11799 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
11801 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: bigint): boolean {
11802 if(!isWasmInitialized) {
11803 throw new Error("initializeWasm() must be awaited first!");
11805 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
11806 return nativeResponseValue;
11808 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
11810 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: bigint): void {
11811 if(!isWasmInitialized) {
11812 throw new Error("initializeWasm() must be awaited first!");
11814 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
11815 // debug statements here
11817 // uint64_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
11819 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: bigint): bigint {
11820 if(!isWasmInitialized) {
11821 throw new Error("initializeWasm() must be awaited first!");
11823 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
11824 return nativeResponseValue;
11826 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
11828 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: bigint): bigint {
11829 if(!isWasmInitialized) {
11830 throw new Error("initializeWasm() must be awaited first!");
11832 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
11833 return nativeResponseValue;
11835 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
11837 export function CResult_SecretKeyNoneZ_ok(o: number): bigint {
11838 if(!isWasmInitialized) {
11839 throw new Error("initializeWasm() must be awaited first!");
11841 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
11842 return nativeResponseValue;
11844 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
11846 export function CResult_SecretKeyNoneZ_err(): bigint {
11847 if(!isWasmInitialized) {
11848 throw new Error("initializeWasm() must be awaited first!");
11850 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
11851 return nativeResponseValue;
11853 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
11855 export function CResult_SecretKeyNoneZ_is_ok(o: bigint): boolean {
11856 if(!isWasmInitialized) {
11857 throw new Error("initializeWasm() must be awaited first!");
11859 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
11860 return nativeResponseValue;
11862 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
11864 export function CResult_SecretKeyNoneZ_free(_res: bigint): void {
11865 if(!isWasmInitialized) {
11866 throw new Error("initializeWasm() must be awaited first!");
11868 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
11869 // debug statements here
11871 // uint64_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
11873 export function CResult_SecretKeyNoneZ_clone_ptr(arg: bigint): bigint {
11874 if(!isWasmInitialized) {
11875 throw new Error("initializeWasm() must be awaited first!");
11877 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
11878 return nativeResponseValue;
11880 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
11882 export function CResult_SecretKeyNoneZ_clone(orig: bigint): bigint {
11883 if(!isWasmInitialized) {
11884 throw new Error("initializeWasm() must be awaited first!");
11886 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
11887 return nativeResponseValue;
11889 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
11891 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
11892 if(!isWasmInitialized) {
11893 throw new Error("initializeWasm() must be awaited first!");
11895 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
11896 return nativeResponseValue;
11898 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
11900 export function CResult_PublicKeyNoneZ_err(): bigint {
11901 if(!isWasmInitialized) {
11902 throw new Error("initializeWasm() must be awaited first!");
11904 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
11905 return nativeResponseValue;
11907 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
11909 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
11910 if(!isWasmInitialized) {
11911 throw new Error("initializeWasm() must be awaited first!");
11913 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
11914 return nativeResponseValue;
11916 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
11918 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
11919 if(!isWasmInitialized) {
11920 throw new Error("initializeWasm() must be awaited first!");
11922 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
11923 // debug statements here
11925 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
11927 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
11928 if(!isWasmInitialized) {
11929 throw new Error("initializeWasm() must be awaited first!");
11931 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
11932 return nativeResponseValue;
11934 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
11936 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
11937 if(!isWasmInitialized) {
11938 throw new Error("initializeWasm() must be awaited first!");
11940 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
11941 return nativeResponseValue;
11943 // struct LDKCOption_ScalarZ COption_ScalarZ_some(struct LDKBigEndianScalar o);
11945 export function COption_ScalarZ_some(o: bigint): bigint {
11946 if(!isWasmInitialized) {
11947 throw new Error("initializeWasm() must be awaited first!");
11949 const nativeResponseValue = wasm.TS_COption_ScalarZ_some(o);
11950 return nativeResponseValue;
11952 // struct LDKCOption_ScalarZ COption_ScalarZ_none(void);
11954 export function COption_ScalarZ_none(): bigint {
11955 if(!isWasmInitialized) {
11956 throw new Error("initializeWasm() must be awaited first!");
11958 const nativeResponseValue = wasm.TS_COption_ScalarZ_none();
11959 return nativeResponseValue;
11961 // void COption_ScalarZ_free(struct LDKCOption_ScalarZ _res);
11963 export function COption_ScalarZ_free(_res: bigint): void {
11964 if(!isWasmInitialized) {
11965 throw new Error("initializeWasm() must be awaited first!");
11967 const nativeResponseValue = wasm.TS_COption_ScalarZ_free(_res);
11968 // debug statements here
11970 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11972 export function CResult_SharedSecretNoneZ_ok(o: number): bigint {
11973 if(!isWasmInitialized) {
11974 throw new Error("initializeWasm() must be awaited first!");
11976 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_ok(o);
11977 return nativeResponseValue;
11979 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_err(void);
11981 export function CResult_SharedSecretNoneZ_err(): bigint {
11982 if(!isWasmInitialized) {
11983 throw new Error("initializeWasm() must be awaited first!");
11985 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_err();
11986 return nativeResponseValue;
11988 // bool CResult_SharedSecretNoneZ_is_ok(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR o);
11990 export function CResult_SharedSecretNoneZ_is_ok(o: bigint): boolean {
11991 if(!isWasmInitialized) {
11992 throw new Error("initializeWasm() must be awaited first!");
11994 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_is_ok(o);
11995 return nativeResponseValue;
11997 // void CResult_SharedSecretNoneZ_free(struct LDKCResult_SharedSecretNoneZ _res);
11999 export function CResult_SharedSecretNoneZ_free(_res: bigint): void {
12000 if(!isWasmInitialized) {
12001 throw new Error("initializeWasm() must be awaited first!");
12003 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_free(_res);
12004 // debug statements here
12006 // uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg);
12008 export function CResult_SharedSecretNoneZ_clone_ptr(arg: bigint): bigint {
12009 if(!isWasmInitialized) {
12010 throw new Error("initializeWasm() must be awaited first!");
12012 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone_ptr(arg);
12013 return nativeResponseValue;
12015 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_clone(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR orig);
12017 export function CResult_SharedSecretNoneZ_clone(orig: bigint): bigint {
12018 if(!isWasmInitialized) {
12019 throw new Error("initializeWasm() must be awaited first!");
12021 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone(orig);
12022 return nativeResponseValue;
12024 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
12026 export function CResult_SignDecodeErrorZ_ok(o: bigint): bigint {
12027 if(!isWasmInitialized) {
12028 throw new Error("initializeWasm() must be awaited first!");
12030 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
12031 return nativeResponseValue;
12033 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
12035 export function CResult_SignDecodeErrorZ_err(e: bigint): bigint {
12036 if(!isWasmInitialized) {
12037 throw new Error("initializeWasm() must be awaited first!");
12039 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
12040 return nativeResponseValue;
12042 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
12044 export function CResult_SignDecodeErrorZ_is_ok(o: bigint): boolean {
12045 if(!isWasmInitialized) {
12046 throw new Error("initializeWasm() must be awaited first!");
12048 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
12049 return nativeResponseValue;
12051 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
12053 export function CResult_SignDecodeErrorZ_free(_res: bigint): void {
12054 if(!isWasmInitialized) {
12055 throw new Error("initializeWasm() must be awaited first!");
12057 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
12058 // debug statements here
12060 // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
12062 export function CResult_SignDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12063 if(!isWasmInitialized) {
12064 throw new Error("initializeWasm() must be awaited first!");
12066 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
12067 return nativeResponseValue;
12069 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
12071 export function CResult_SignDecodeErrorZ_clone(orig: bigint): bigint {
12072 if(!isWasmInitialized) {
12073 throw new Error("initializeWasm() must be awaited first!");
12075 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
12076 return nativeResponseValue;
12078 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12080 export function CVec_U5Z_free(_res: number): void {
12081 if(!isWasmInitialized) {
12082 throw new Error("initializeWasm() must be awaited first!");
12084 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12085 // debug statements here
12087 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12089 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12090 if(!isWasmInitialized) {
12091 throw new Error("initializeWasm() must be awaited first!");
12093 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
12094 return nativeResponseValue;
12096 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
12098 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
12099 if(!isWasmInitialized) {
12100 throw new Error("initializeWasm() must be awaited first!");
12102 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
12103 return nativeResponseValue;
12105 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
12107 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
12108 if(!isWasmInitialized) {
12109 throw new Error("initializeWasm() must be awaited first!");
12111 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
12112 return nativeResponseValue;
12114 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
12116 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
12117 if(!isWasmInitialized) {
12118 throw new Error("initializeWasm() must be awaited first!");
12120 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
12121 // debug statements here
12123 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
12125 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12126 if(!isWasmInitialized) {
12127 throw new Error("initializeWasm() must be awaited first!");
12129 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
12130 return nativeResponseValue;
12132 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
12134 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
12135 if(!isWasmInitialized) {
12136 throw new Error("initializeWasm() must be awaited first!");
12138 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
12139 return nativeResponseValue;
12141 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
12143 export function CVec_u8Z_free(_res: number): void {
12144 if(!isWasmInitialized) {
12145 throw new Error("initializeWasm() must be awaited first!");
12147 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
12148 // debug statements here
12150 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
12152 export function CVec_CVec_u8ZZ_free(_res: number): void {
12153 if(!isWasmInitialized) {
12154 throw new Error("initializeWasm() must be awaited first!");
12156 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
12157 // debug statements here
12159 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
12161 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
12162 if(!isWasmInitialized) {
12163 throw new Error("initializeWasm() must be awaited first!");
12165 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
12166 return nativeResponseValue;
12168 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
12170 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
12171 if(!isWasmInitialized) {
12172 throw new Error("initializeWasm() must be awaited first!");
12174 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
12175 return nativeResponseValue;
12177 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
12179 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
12180 if(!isWasmInitialized) {
12181 throw new Error("initializeWasm() must be awaited first!");
12183 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
12184 return nativeResponseValue;
12186 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
12188 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
12189 if(!isWasmInitialized) {
12190 throw new Error("initializeWasm() must be awaited first!");
12192 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
12193 // debug statements here
12195 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
12197 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
12198 if(!isWasmInitialized) {
12199 throw new Error("initializeWasm() must be awaited first!");
12201 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
12202 return nativeResponseValue;
12204 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
12206 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
12207 if(!isWasmInitialized) {
12208 throw new Error("initializeWasm() must be awaited first!");
12210 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
12211 return nativeResponseValue;
12213 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
12215 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
12216 if(!isWasmInitialized) {
12217 throw new Error("initializeWasm() must be awaited first!");
12219 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
12220 return nativeResponseValue;
12222 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
12224 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
12225 if(!isWasmInitialized) {
12226 throw new Error("initializeWasm() must be awaited first!");
12228 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
12229 return nativeResponseValue;
12231 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
12233 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
12234 if(!isWasmInitialized) {
12235 throw new Error("initializeWasm() must be awaited first!");
12237 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
12238 return nativeResponseValue;
12240 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
12242 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
12243 if(!isWasmInitialized) {
12244 throw new Error("initializeWasm() must be awaited first!");
12246 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
12247 // debug statements here
12249 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
12251 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12252 if(!isWasmInitialized) {
12253 throw new Error("initializeWasm() must be awaited first!");
12255 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
12256 return nativeResponseValue;
12258 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
12260 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
12261 if(!isWasmInitialized) {
12262 throw new Error("initializeWasm() must be awaited first!");
12264 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
12265 return nativeResponseValue;
12267 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
12269 export function CVec_TxOutZ_free(_res: number): void {
12270 if(!isWasmInitialized) {
12271 throw new Error("initializeWasm() must be awaited first!");
12273 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
12274 // debug statements here
12276 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
12278 export function CResult_TransactionNoneZ_ok(o: number): bigint {
12279 if(!isWasmInitialized) {
12280 throw new Error("initializeWasm() must be awaited first!");
12282 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
12283 return nativeResponseValue;
12285 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
12287 export function CResult_TransactionNoneZ_err(): bigint {
12288 if(!isWasmInitialized) {
12289 throw new Error("initializeWasm() must be awaited first!");
12291 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
12292 return nativeResponseValue;
12294 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
12296 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
12297 if(!isWasmInitialized) {
12298 throw new Error("initializeWasm() must be awaited first!");
12300 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
12301 return nativeResponseValue;
12303 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
12305 export function CResult_TransactionNoneZ_free(_res: bigint): void {
12306 if(!isWasmInitialized) {
12307 throw new Error("initializeWasm() must be awaited first!");
12309 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
12310 // debug statements here
12312 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
12314 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
12315 if(!isWasmInitialized) {
12316 throw new Error("initializeWasm() must be awaited first!");
12318 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
12319 return nativeResponseValue;
12321 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
12323 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
12324 if(!isWasmInitialized) {
12325 throw new Error("initializeWasm() must be awaited first!");
12327 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
12328 return nativeResponseValue;
12330 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
12332 export function COption_u16Z_some(o: number): bigint {
12333 if(!isWasmInitialized) {
12334 throw new Error("initializeWasm() must be awaited first!");
12336 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
12337 return nativeResponseValue;
12339 // struct LDKCOption_u16Z COption_u16Z_none(void);
12341 export function COption_u16Z_none(): bigint {
12342 if(!isWasmInitialized) {
12343 throw new Error("initializeWasm() must be awaited first!");
12345 const nativeResponseValue = wasm.TS_COption_u16Z_none();
12346 return nativeResponseValue;
12348 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
12350 export function COption_u16Z_free(_res: bigint): void {
12351 if(!isWasmInitialized) {
12352 throw new Error("initializeWasm() must be awaited first!");
12354 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
12355 // debug statements here
12357 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
12359 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
12360 if(!isWasmInitialized) {
12361 throw new Error("initializeWasm() must be awaited first!");
12363 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
12364 return nativeResponseValue;
12366 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
12368 export function COption_u16Z_clone(orig: bigint): bigint {
12369 if(!isWasmInitialized) {
12370 throw new Error("initializeWasm() must be awaited first!");
12372 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
12373 return nativeResponseValue;
12375 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
12377 export function CResult_NoneAPIErrorZ_ok(): bigint {
12378 if(!isWasmInitialized) {
12379 throw new Error("initializeWasm() must be awaited first!");
12381 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
12382 return nativeResponseValue;
12384 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
12386 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
12387 if(!isWasmInitialized) {
12388 throw new Error("initializeWasm() must be awaited first!");
12390 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
12391 return nativeResponseValue;
12393 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
12395 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
12396 if(!isWasmInitialized) {
12397 throw new Error("initializeWasm() must be awaited first!");
12399 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
12400 return nativeResponseValue;
12402 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
12404 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
12405 if(!isWasmInitialized) {
12406 throw new Error("initializeWasm() must be awaited first!");
12408 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
12409 // debug statements here
12411 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
12413 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
12414 if(!isWasmInitialized) {
12415 throw new Error("initializeWasm() must be awaited first!");
12417 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
12418 return nativeResponseValue;
12420 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
12422 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
12423 if(!isWasmInitialized) {
12424 throw new Error("initializeWasm() must be awaited first!");
12426 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
12427 return nativeResponseValue;
12429 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
12431 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
12432 if(!isWasmInitialized) {
12433 throw new Error("initializeWasm() must be awaited first!");
12435 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
12436 // debug statements here
12438 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
12440 export function CVec_APIErrorZ_free(_res: number): void {
12441 if(!isWasmInitialized) {
12442 throw new Error("initializeWasm() must be awaited first!");
12444 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
12445 // debug statements here
12447 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
12449 export function CResult__u832APIErrorZ_ok(o: number): bigint {
12450 if(!isWasmInitialized) {
12451 throw new Error("initializeWasm() must be awaited first!");
12453 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
12454 return nativeResponseValue;
12456 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
12458 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
12459 if(!isWasmInitialized) {
12460 throw new Error("initializeWasm() must be awaited first!");
12462 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
12463 return nativeResponseValue;
12465 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
12467 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
12468 if(!isWasmInitialized) {
12469 throw new Error("initializeWasm() must be awaited first!");
12471 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
12472 return nativeResponseValue;
12474 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
12476 export function CResult__u832APIErrorZ_free(_res: bigint): void {
12477 if(!isWasmInitialized) {
12478 throw new Error("initializeWasm() must be awaited first!");
12480 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
12481 // debug statements here
12483 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
12485 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
12486 if(!isWasmInitialized) {
12487 throw new Error("initializeWasm() must be awaited first!");
12489 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
12490 return nativeResponseValue;
12492 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
12494 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
12495 if(!isWasmInitialized) {
12496 throw new Error("initializeWasm() must be awaited first!");
12498 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
12499 return nativeResponseValue;
12501 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
12503 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
12504 if(!isWasmInitialized) {
12505 throw new Error("initializeWasm() must be awaited first!");
12507 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
12508 return nativeResponseValue;
12510 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12512 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
12513 if(!isWasmInitialized) {
12514 throw new Error("initializeWasm() must be awaited first!");
12516 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
12517 return nativeResponseValue;
12519 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
12521 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
12522 if(!isWasmInitialized) {
12523 throw new Error("initializeWasm() must be awaited first!");
12525 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
12526 return nativeResponseValue;
12528 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
12530 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
12531 if(!isWasmInitialized) {
12532 throw new Error("initializeWasm() must be awaited first!");
12534 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
12535 // debug statements here
12537 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
12539 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12540 if(!isWasmInitialized) {
12541 throw new Error("initializeWasm() must be awaited first!");
12543 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
12544 return nativeResponseValue;
12546 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
12548 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
12549 if(!isWasmInitialized) {
12550 throw new Error("initializeWasm() must be awaited first!");
12552 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
12553 return nativeResponseValue;
12555 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
12557 export function CResult_PaymentHashPaymentSendFailureZ_ok(o: number): bigint {
12558 if(!isWasmInitialized) {
12559 throw new Error("initializeWasm() must be awaited first!");
12561 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_ok(o);
12562 return nativeResponseValue;
12564 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12566 export function CResult_PaymentHashPaymentSendFailureZ_err(e: bigint): bigint {
12567 if(!isWasmInitialized) {
12568 throw new Error("initializeWasm() must be awaited first!");
12570 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_err(e);
12571 return nativeResponseValue;
12573 // bool CResult_PaymentHashPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR o);
12575 export function CResult_PaymentHashPaymentSendFailureZ_is_ok(o: bigint): boolean {
12576 if(!isWasmInitialized) {
12577 throw new Error("initializeWasm() must be awaited first!");
12579 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(o);
12580 return nativeResponseValue;
12582 // void CResult_PaymentHashPaymentSendFailureZ_free(struct LDKCResult_PaymentHashPaymentSendFailureZ _res);
12584 export function CResult_PaymentHashPaymentSendFailureZ_free(_res: bigint): void {
12585 if(!isWasmInitialized) {
12586 throw new Error("initializeWasm() must be awaited first!");
12588 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_free(_res);
12589 // debug statements here
12591 // uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg);
12593 export function CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12594 if(!isWasmInitialized) {
12595 throw new Error("initializeWasm() must be awaited first!");
12597 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg);
12598 return nativeResponseValue;
12600 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_clone(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR orig);
12602 export function CResult_PaymentHashPaymentSendFailureZ_clone(orig: bigint): bigint {
12603 if(!isWasmInitialized) {
12604 throw new Error("initializeWasm() must be awaited first!");
12606 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone(orig);
12607 return nativeResponseValue;
12609 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
12611 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
12612 if(!isWasmInitialized) {
12613 throw new Error("initializeWasm() must be awaited first!");
12615 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
12616 return nativeResponseValue;
12618 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
12620 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
12621 if(!isWasmInitialized) {
12622 throw new Error("initializeWasm() must be awaited first!");
12624 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
12625 return nativeResponseValue;
12627 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12629 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
12630 if(!isWasmInitialized) {
12631 throw new Error("initializeWasm() must be awaited first!");
12633 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
12634 return nativeResponseValue;
12636 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
12638 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
12639 if(!isWasmInitialized) {
12640 throw new Error("initializeWasm() must be awaited first!");
12642 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
12643 // debug statements here
12645 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
12647 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
12648 if(!isWasmInitialized) {
12649 throw new Error("initializeWasm() must be awaited first!");
12651 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
12652 return nativeResponseValue;
12654 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
12656 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
12657 if(!isWasmInitialized) {
12658 throw new Error("initializeWasm() must be awaited first!");
12660 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
12661 return nativeResponseValue;
12663 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
12665 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
12666 if(!isWasmInitialized) {
12667 throw new Error("initializeWasm() must be awaited first!");
12669 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
12670 return nativeResponseValue;
12672 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
12674 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
12675 if(!isWasmInitialized) {
12676 throw new Error("initializeWasm() must be awaited first!");
12678 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
12679 // debug statements here
12681 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
12683 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
12684 if(!isWasmInitialized) {
12685 throw new Error("initializeWasm() must be awaited first!");
12687 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
12688 return nativeResponseValue;
12690 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
12692 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
12693 if(!isWasmInitialized) {
12694 throw new Error("initializeWasm() must be awaited first!");
12696 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
12697 return nativeResponseValue;
12699 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
12701 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
12702 if(!isWasmInitialized) {
12703 throw new Error("initializeWasm() must be awaited first!");
12705 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
12706 // debug statements here
12708 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
12710 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
12711 if(!isWasmInitialized) {
12712 throw new Error("initializeWasm() must be awaited first!");
12714 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
12715 return nativeResponseValue;
12717 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
12719 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
12720 if(!isWasmInitialized) {
12721 throw new Error("initializeWasm() must be awaited first!");
12723 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
12724 return nativeResponseValue;
12726 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
12728 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
12729 if(!isWasmInitialized) {
12730 throw new Error("initializeWasm() must be awaited first!");
12732 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
12733 return nativeResponseValue;
12735 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
12737 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
12738 if(!isWasmInitialized) {
12739 throw new Error("initializeWasm() must be awaited first!");
12741 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
12742 // debug statements here
12744 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12746 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
12747 if(!isWasmInitialized) {
12748 throw new Error("initializeWasm() must be awaited first!");
12750 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
12751 return nativeResponseValue;
12753 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
12755 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
12756 if(!isWasmInitialized) {
12757 throw new Error("initializeWasm() must be awaited first!");
12759 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
12760 return nativeResponseValue;
12762 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
12764 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
12765 if(!isWasmInitialized) {
12766 throw new Error("initializeWasm() must be awaited first!");
12768 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
12769 return nativeResponseValue;
12771 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
12773 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
12774 if(!isWasmInitialized) {
12775 throw new Error("initializeWasm() must be awaited first!");
12777 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
12778 // debug statements here
12780 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
12782 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
12783 if(!isWasmInitialized) {
12784 throw new Error("initializeWasm() must be awaited first!");
12786 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
12787 return nativeResponseValue;
12789 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
12791 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
12792 if(!isWasmInitialized) {
12793 throw new Error("initializeWasm() must be awaited first!");
12795 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
12796 return nativeResponseValue;
12798 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
12800 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: bigint): bigint {
12801 if(!isWasmInitialized) {
12802 throw new Error("initializeWasm() must be awaited first!");
12804 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
12805 return nativeResponseValue;
12807 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
12809 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: bigint): bigint {
12810 if(!isWasmInitialized) {
12811 throw new Error("initializeWasm() must be awaited first!");
12813 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
12814 return nativeResponseValue;
12816 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
12818 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: bigint): boolean {
12819 if(!isWasmInitialized) {
12820 throw new Error("initializeWasm() must be awaited first!");
12822 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
12823 return nativeResponseValue;
12825 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
12827 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: bigint): void {
12828 if(!isWasmInitialized) {
12829 throw new Error("initializeWasm() must be awaited first!");
12831 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
12832 // debug statements here
12834 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
12836 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: bigint): bigint {
12837 if(!isWasmInitialized) {
12838 throw new Error("initializeWasm() must be awaited first!");
12840 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
12841 return nativeResponseValue;
12843 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
12845 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: bigint): bigint {
12846 if(!isWasmInitialized) {
12847 throw new Error("initializeWasm() must be awaited first!");
12849 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
12850 return nativeResponseValue;
12852 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12854 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
12855 if(!isWasmInitialized) {
12856 throw new Error("initializeWasm() must be awaited first!");
12858 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
12859 return nativeResponseValue;
12861 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
12863 export function CResult_PaymentSecretNoneZ_err(): bigint {
12864 if(!isWasmInitialized) {
12865 throw new Error("initializeWasm() must be awaited first!");
12867 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
12868 return nativeResponseValue;
12870 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
12872 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
12873 if(!isWasmInitialized) {
12874 throw new Error("initializeWasm() must be awaited first!");
12876 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
12877 return nativeResponseValue;
12879 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
12881 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
12882 if(!isWasmInitialized) {
12883 throw new Error("initializeWasm() must be awaited first!");
12885 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
12886 // debug statements here
12888 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
12890 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
12891 if(!isWasmInitialized) {
12892 throw new Error("initializeWasm() must be awaited first!");
12894 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
12895 return nativeResponseValue;
12897 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
12899 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
12900 if(!isWasmInitialized) {
12901 throw new Error("initializeWasm() must be awaited first!");
12903 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
12904 return nativeResponseValue;
12906 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12908 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): bigint {
12909 if(!isWasmInitialized) {
12910 throw new Error("initializeWasm() must be awaited first!");
12912 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
12913 return nativeResponseValue;
12915 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
12917 export function CResult_PaymentSecretAPIErrorZ_err(e: bigint): bigint {
12918 if(!isWasmInitialized) {
12919 throw new Error("initializeWasm() must be awaited first!");
12921 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
12922 return nativeResponseValue;
12924 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
12926 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: bigint): boolean {
12927 if(!isWasmInitialized) {
12928 throw new Error("initializeWasm() must be awaited first!");
12930 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
12931 return nativeResponseValue;
12933 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
12935 export function CResult_PaymentSecretAPIErrorZ_free(_res: bigint): void {
12936 if(!isWasmInitialized) {
12937 throw new Error("initializeWasm() must be awaited first!");
12939 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
12940 // debug statements here
12942 // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
12944 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: bigint): bigint {
12945 if(!isWasmInitialized) {
12946 throw new Error("initializeWasm() must be awaited first!");
12948 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
12949 return nativeResponseValue;
12951 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
12953 export function CResult_PaymentSecretAPIErrorZ_clone(orig: bigint): bigint {
12954 if(!isWasmInitialized) {
12955 throw new Error("initializeWasm() must be awaited first!");
12957 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
12958 return nativeResponseValue;
12960 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12962 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
12963 if(!isWasmInitialized) {
12964 throw new Error("initializeWasm() must be awaited first!");
12966 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
12967 return nativeResponseValue;
12969 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
12971 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
12972 if(!isWasmInitialized) {
12973 throw new Error("initializeWasm() must be awaited first!");
12975 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
12976 return nativeResponseValue;
12978 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
12980 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
12981 if(!isWasmInitialized) {
12982 throw new Error("initializeWasm() must be awaited first!");
12984 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
12985 return nativeResponseValue;
12987 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
12989 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
12990 if(!isWasmInitialized) {
12991 throw new Error("initializeWasm() must be awaited first!");
12993 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
12994 // debug statements here
12996 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
12998 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
12999 if(!isWasmInitialized) {
13000 throw new Error("initializeWasm() must be awaited first!");
13002 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
13003 return nativeResponseValue;
13005 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
13007 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
13008 if(!isWasmInitialized) {
13009 throw new Error("initializeWasm() must be awaited first!");
13011 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
13012 return nativeResponseValue;
13014 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
13016 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
13017 if(!isWasmInitialized) {
13018 throw new Error("initializeWasm() must be awaited first!");
13020 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
13021 return nativeResponseValue;
13023 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
13025 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
13026 if(!isWasmInitialized) {
13027 throw new Error("initializeWasm() must be awaited first!");
13029 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
13030 return nativeResponseValue;
13032 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
13034 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
13035 if(!isWasmInitialized) {
13036 throw new Error("initializeWasm() must be awaited first!");
13038 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
13039 return nativeResponseValue;
13041 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
13043 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
13044 if(!isWasmInitialized) {
13045 throw new Error("initializeWasm() must be awaited first!");
13047 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
13048 // debug statements here
13050 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
13052 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13053 if(!isWasmInitialized) {
13054 throw new Error("initializeWasm() must be awaited first!");
13056 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
13057 return nativeResponseValue;
13059 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
13061 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
13062 if(!isWasmInitialized) {
13063 throw new Error("initializeWasm() must be awaited first!");
13065 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
13066 return nativeResponseValue;
13068 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
13070 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
13071 if(!isWasmInitialized) {
13072 throw new Error("initializeWasm() must be awaited first!");
13074 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
13075 return nativeResponseValue;
13077 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
13079 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
13080 if(!isWasmInitialized) {
13081 throw new Error("initializeWasm() must be awaited first!");
13083 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
13084 return nativeResponseValue;
13086 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
13088 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
13089 if(!isWasmInitialized) {
13090 throw new Error("initializeWasm() must be awaited first!");
13092 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
13093 return nativeResponseValue;
13095 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
13097 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
13098 if(!isWasmInitialized) {
13099 throw new Error("initializeWasm() must be awaited first!");
13101 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
13102 // debug statements here
13104 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
13106 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13107 if(!isWasmInitialized) {
13108 throw new Error("initializeWasm() must be awaited first!");
13110 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
13111 return nativeResponseValue;
13113 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
13115 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
13116 if(!isWasmInitialized) {
13117 throw new Error("initializeWasm() must be awaited first!");
13119 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
13120 return nativeResponseValue;
13122 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
13124 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
13125 if(!isWasmInitialized) {
13126 throw new Error("initializeWasm() must be awaited first!");
13128 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
13129 return nativeResponseValue;
13131 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
13133 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
13134 if(!isWasmInitialized) {
13135 throw new Error("initializeWasm() must be awaited first!");
13137 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
13138 return nativeResponseValue;
13140 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
13142 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
13143 if(!isWasmInitialized) {
13144 throw new Error("initializeWasm() must be awaited first!");
13146 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
13147 return nativeResponseValue;
13149 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
13151 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
13152 if(!isWasmInitialized) {
13153 throw new Error("initializeWasm() must be awaited first!");
13155 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
13156 // debug statements here
13158 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
13160 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13161 if(!isWasmInitialized) {
13162 throw new Error("initializeWasm() must be awaited first!");
13164 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
13165 return nativeResponseValue;
13167 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
13169 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
13170 if(!isWasmInitialized) {
13171 throw new Error("initializeWasm() must be awaited first!");
13173 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
13174 return nativeResponseValue;
13176 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
13178 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
13179 if(!isWasmInitialized) {
13180 throw new Error("initializeWasm() must be awaited first!");
13182 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
13183 return nativeResponseValue;
13185 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
13187 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
13188 if(!isWasmInitialized) {
13189 throw new Error("initializeWasm() must be awaited first!");
13191 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
13192 return nativeResponseValue;
13194 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
13196 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
13197 if(!isWasmInitialized) {
13198 throw new Error("initializeWasm() must be awaited first!");
13200 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
13201 return nativeResponseValue;
13203 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
13205 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
13206 if(!isWasmInitialized) {
13207 throw new Error("initializeWasm() must be awaited first!");
13209 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
13210 // debug statements here
13212 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
13214 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13215 if(!isWasmInitialized) {
13216 throw new Error("initializeWasm() must be awaited first!");
13218 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
13219 return nativeResponseValue;
13221 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
13223 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
13224 if(!isWasmInitialized) {
13225 throw new Error("initializeWasm() must be awaited first!");
13227 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
13228 return nativeResponseValue;
13230 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
13232 export function CVec_ChannelMonitorZ_free(_res: number): void {
13233 if(!isWasmInitialized) {
13234 throw new Error("initializeWasm() must be awaited first!");
13236 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
13237 // debug statements here
13239 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
13241 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
13242 if(!isWasmInitialized) {
13243 throw new Error("initializeWasm() must be awaited first!");
13245 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
13246 return nativeResponseValue;
13248 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
13250 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
13251 if(!isWasmInitialized) {
13252 throw new Error("initializeWasm() must be awaited first!");
13254 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
13255 // debug statements here
13257 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
13259 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
13260 if(!isWasmInitialized) {
13261 throw new Error("initializeWasm() must be awaited first!");
13263 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
13264 return nativeResponseValue;
13266 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
13268 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
13269 if(!isWasmInitialized) {
13270 throw new Error("initializeWasm() must be awaited first!");
13272 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
13273 return nativeResponseValue;
13275 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
13277 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
13278 if(!isWasmInitialized) {
13279 throw new Error("initializeWasm() must be awaited first!");
13281 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
13282 return nativeResponseValue;
13284 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
13286 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
13287 if(!isWasmInitialized) {
13288 throw new Error("initializeWasm() must be awaited first!");
13290 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
13291 // debug statements here
13293 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
13295 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
13296 if(!isWasmInitialized) {
13297 throw new Error("initializeWasm() must be awaited first!");
13299 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
13300 return nativeResponseValue;
13302 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
13304 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
13305 if(!isWasmInitialized) {
13306 throw new Error("initializeWasm() must be awaited first!");
13308 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
13309 return nativeResponseValue;
13311 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
13313 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
13314 if(!isWasmInitialized) {
13315 throw new Error("initializeWasm() must be awaited first!");
13317 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
13318 return nativeResponseValue;
13320 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
13322 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
13323 if(!isWasmInitialized) {
13324 throw new Error("initializeWasm() must be awaited first!");
13326 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
13327 // debug statements here
13329 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
13331 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13332 if(!isWasmInitialized) {
13333 throw new Error("initializeWasm() must be awaited first!");
13335 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
13336 return nativeResponseValue;
13338 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
13340 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
13341 if(!isWasmInitialized) {
13342 throw new Error("initializeWasm() must be awaited first!");
13344 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
13345 return nativeResponseValue;
13347 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
13349 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
13350 if(!isWasmInitialized) {
13351 throw new Error("initializeWasm() must be awaited first!");
13353 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
13354 return nativeResponseValue;
13356 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
13358 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
13359 if(!isWasmInitialized) {
13360 throw new Error("initializeWasm() must be awaited first!");
13362 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
13363 return nativeResponseValue;
13365 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
13367 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
13368 if(!isWasmInitialized) {
13369 throw new Error("initializeWasm() must be awaited first!");
13371 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
13372 return nativeResponseValue;
13374 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
13376 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
13377 if(!isWasmInitialized) {
13378 throw new Error("initializeWasm() must be awaited first!");
13380 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
13381 // debug statements here
13383 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
13385 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13386 if(!isWasmInitialized) {
13387 throw new Error("initializeWasm() must be awaited first!");
13389 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
13390 return nativeResponseValue;
13392 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
13394 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
13395 if(!isWasmInitialized) {
13396 throw new Error("initializeWasm() must be awaited first!");
13398 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
13399 return nativeResponseValue;
13401 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
13403 export function COption_TypeZ_some(o: bigint): bigint {
13404 if(!isWasmInitialized) {
13405 throw new Error("initializeWasm() must be awaited first!");
13407 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
13408 return nativeResponseValue;
13410 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
13412 export function COption_TypeZ_none(): bigint {
13413 if(!isWasmInitialized) {
13414 throw new Error("initializeWasm() must be awaited first!");
13416 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
13417 return nativeResponseValue;
13419 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
13421 export function COption_TypeZ_free(_res: bigint): void {
13422 if(!isWasmInitialized) {
13423 throw new Error("initializeWasm() must be awaited first!");
13425 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
13426 // debug statements here
13428 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
13430 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
13431 if(!isWasmInitialized) {
13432 throw new Error("initializeWasm() must be awaited first!");
13434 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
13435 return nativeResponseValue;
13437 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
13439 export function COption_TypeZ_clone(orig: bigint): bigint {
13440 if(!isWasmInitialized) {
13441 throw new Error("initializeWasm() must be awaited first!");
13443 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
13444 return nativeResponseValue;
13446 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
13448 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
13449 if(!isWasmInitialized) {
13450 throw new Error("initializeWasm() must be awaited first!");
13452 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
13453 return nativeResponseValue;
13455 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
13457 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
13458 if(!isWasmInitialized) {
13459 throw new Error("initializeWasm() must be awaited first!");
13461 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
13462 return nativeResponseValue;
13464 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
13466 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
13467 if(!isWasmInitialized) {
13468 throw new Error("initializeWasm() must be awaited first!");
13470 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
13471 return nativeResponseValue;
13473 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
13475 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
13476 if(!isWasmInitialized) {
13477 throw new Error("initializeWasm() must be awaited first!");
13479 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
13480 // debug statements here
13482 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
13484 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13485 if(!isWasmInitialized) {
13486 throw new Error("initializeWasm() must be awaited first!");
13488 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
13489 return nativeResponseValue;
13491 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
13493 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
13494 if(!isWasmInitialized) {
13495 throw new Error("initializeWasm() must be awaited first!");
13497 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
13498 return nativeResponseValue;
13500 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
13502 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
13503 if(!isWasmInitialized) {
13504 throw new Error("initializeWasm() must be awaited first!");
13506 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
13507 return nativeResponseValue;
13509 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
13511 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
13512 if(!isWasmInitialized) {
13513 throw new Error("initializeWasm() must be awaited first!");
13515 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
13516 return nativeResponseValue;
13518 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
13520 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
13521 if(!isWasmInitialized) {
13522 throw new Error("initializeWasm() must be awaited first!");
13524 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
13525 return nativeResponseValue;
13527 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
13529 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
13530 if(!isWasmInitialized) {
13531 throw new Error("initializeWasm() must be awaited first!");
13533 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
13534 // debug statements here
13536 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
13538 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
13539 if(!isWasmInitialized) {
13540 throw new Error("initializeWasm() must be awaited first!");
13542 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
13543 return nativeResponseValue;
13545 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
13547 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
13548 if(!isWasmInitialized) {
13549 throw new Error("initializeWasm() must be awaited first!");
13551 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
13552 return nativeResponseValue;
13554 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_ok(void);
13556 export function CResult_NonePaymentErrorZ_ok(): bigint {
13557 if(!isWasmInitialized) {
13558 throw new Error("initializeWasm() must be awaited first!");
13560 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_ok();
13561 return nativeResponseValue;
13563 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_err(struct LDKPaymentError e);
13565 export function CResult_NonePaymentErrorZ_err(e: bigint): bigint {
13566 if(!isWasmInitialized) {
13567 throw new Error("initializeWasm() must be awaited first!");
13569 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_err(e);
13570 return nativeResponseValue;
13572 // bool CResult_NonePaymentErrorZ_is_ok(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR o);
13574 export function CResult_NonePaymentErrorZ_is_ok(o: bigint): boolean {
13575 if(!isWasmInitialized) {
13576 throw new Error("initializeWasm() must be awaited first!");
13578 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_is_ok(o);
13579 return nativeResponseValue;
13581 // void CResult_NonePaymentErrorZ_free(struct LDKCResult_NonePaymentErrorZ _res);
13583 export function CResult_NonePaymentErrorZ_free(_res: bigint): void {
13584 if(!isWasmInitialized) {
13585 throw new Error("initializeWasm() must be awaited first!");
13587 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_free(_res);
13588 // debug statements here
13590 // uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg);
13592 export function CResult_NonePaymentErrorZ_clone_ptr(arg: bigint): bigint {
13593 if(!isWasmInitialized) {
13594 throw new Error("initializeWasm() must be awaited first!");
13596 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone_ptr(arg);
13597 return nativeResponseValue;
13599 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_clone(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR orig);
13601 export function CResult_NonePaymentErrorZ_clone(orig: bigint): bigint {
13602 if(!isWasmInitialized) {
13603 throw new Error("initializeWasm() must be awaited first!");
13605 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone(orig);
13606 return nativeResponseValue;
13608 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
13610 export function CResult_StringErrorZ_ok(o: number): bigint {
13611 if(!isWasmInitialized) {
13612 throw new Error("initializeWasm() must be awaited first!");
13614 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
13615 return nativeResponseValue;
13617 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
13619 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
13620 if(!isWasmInitialized) {
13621 throw new Error("initializeWasm() must be awaited first!");
13623 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
13624 return nativeResponseValue;
13626 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
13628 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
13629 if(!isWasmInitialized) {
13630 throw new Error("initializeWasm() must be awaited first!");
13632 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
13633 return nativeResponseValue;
13635 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
13637 export function CResult_StringErrorZ_free(_res: bigint): void {
13638 if(!isWasmInitialized) {
13639 throw new Error("initializeWasm() must be awaited first!");
13641 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
13642 // debug statements here
13644 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
13646 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
13647 if(!isWasmInitialized) {
13648 throw new Error("initializeWasm() must be awaited first!");
13650 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
13651 return nativeResponseValue;
13653 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
13655 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
13656 if(!isWasmInitialized) {
13657 throw new Error("initializeWasm() must be awaited first!");
13659 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
13660 return nativeResponseValue;
13662 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
13664 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
13665 if(!isWasmInitialized) {
13666 throw new Error("initializeWasm() must be awaited first!");
13668 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
13669 return nativeResponseValue;
13671 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
13673 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
13674 if(!isWasmInitialized) {
13675 throw new Error("initializeWasm() must be awaited first!");
13677 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
13678 return nativeResponseValue;
13680 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
13682 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
13683 if(!isWasmInitialized) {
13684 throw new Error("initializeWasm() must be awaited first!");
13686 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
13687 return nativeResponseValue;
13689 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
13691 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
13692 if(!isWasmInitialized) {
13693 throw new Error("initializeWasm() must be awaited first!");
13695 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
13696 // debug statements here
13698 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
13700 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
13701 if(!isWasmInitialized) {
13702 throw new Error("initializeWasm() must be awaited first!");
13704 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
13705 return nativeResponseValue;
13707 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
13709 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
13710 if(!isWasmInitialized) {
13711 throw new Error("initializeWasm() must be awaited first!");
13713 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
13714 return nativeResponseValue;
13716 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
13718 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
13719 if(!isWasmInitialized) {
13720 throw new Error("initializeWasm() must be awaited first!");
13722 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
13723 return nativeResponseValue;
13725 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13727 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
13728 if(!isWasmInitialized) {
13729 throw new Error("initializeWasm() must be awaited first!");
13731 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
13732 return nativeResponseValue;
13734 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
13736 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13737 if(!isWasmInitialized) {
13738 throw new Error("initializeWasm() must be awaited first!");
13740 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
13741 return nativeResponseValue;
13743 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
13745 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
13746 if(!isWasmInitialized) {
13747 throw new Error("initializeWasm() must be awaited first!");
13749 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
13750 // debug statements here
13752 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
13754 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13755 if(!isWasmInitialized) {
13756 throw new Error("initializeWasm() must be awaited first!");
13758 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
13759 return nativeResponseValue;
13761 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
13763 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13764 if(!isWasmInitialized) {
13765 throw new Error("initializeWasm() must be awaited first!");
13767 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
13768 return nativeResponseValue;
13770 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
13772 export function COption_MonitorEventZ_some(o: bigint): bigint {
13773 if(!isWasmInitialized) {
13774 throw new Error("initializeWasm() must be awaited first!");
13776 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
13777 return nativeResponseValue;
13779 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
13781 export function COption_MonitorEventZ_none(): bigint {
13782 if(!isWasmInitialized) {
13783 throw new Error("initializeWasm() must be awaited first!");
13785 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
13786 return nativeResponseValue;
13788 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
13790 export function COption_MonitorEventZ_free(_res: bigint): void {
13791 if(!isWasmInitialized) {
13792 throw new Error("initializeWasm() must be awaited first!");
13794 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
13795 // debug statements here
13797 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
13799 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
13800 if(!isWasmInitialized) {
13801 throw new Error("initializeWasm() must be awaited first!");
13803 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
13804 return nativeResponseValue;
13806 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
13808 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
13809 if(!isWasmInitialized) {
13810 throw new Error("initializeWasm() must be awaited first!");
13812 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
13813 return nativeResponseValue;
13815 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
13817 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
13818 if(!isWasmInitialized) {
13819 throw new Error("initializeWasm() must be awaited first!");
13821 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
13822 return nativeResponseValue;
13824 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
13826 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
13827 if(!isWasmInitialized) {
13828 throw new Error("initializeWasm() must be awaited first!");
13830 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
13831 return nativeResponseValue;
13833 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
13835 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
13836 if(!isWasmInitialized) {
13837 throw new Error("initializeWasm() must be awaited first!");
13839 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
13840 return nativeResponseValue;
13842 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
13844 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
13845 if(!isWasmInitialized) {
13846 throw new Error("initializeWasm() must be awaited first!");
13848 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
13849 // debug statements here
13851 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
13853 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13854 if(!isWasmInitialized) {
13855 throw new Error("initializeWasm() must be awaited first!");
13857 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
13858 return nativeResponseValue;
13860 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
13862 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
13863 if(!isWasmInitialized) {
13864 throw new Error("initializeWasm() must be awaited first!");
13866 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
13867 return nativeResponseValue;
13869 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
13871 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
13872 if(!isWasmInitialized) {
13873 throw new Error("initializeWasm() must be awaited first!");
13875 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
13876 return nativeResponseValue;
13878 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13880 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
13881 if(!isWasmInitialized) {
13882 throw new Error("initializeWasm() must be awaited first!");
13884 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
13885 return nativeResponseValue;
13887 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
13889 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
13890 if(!isWasmInitialized) {
13891 throw new Error("initializeWasm() must be awaited first!");
13893 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
13894 return nativeResponseValue;
13896 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
13898 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
13899 if(!isWasmInitialized) {
13900 throw new Error("initializeWasm() must be awaited first!");
13902 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
13903 // debug statements here
13905 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
13907 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13908 if(!isWasmInitialized) {
13909 throw new Error("initializeWasm() must be awaited first!");
13911 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
13912 return nativeResponseValue;
13914 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
13916 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
13917 if(!isWasmInitialized) {
13918 throw new Error("initializeWasm() must be awaited first!");
13920 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
13921 return nativeResponseValue;
13923 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
13925 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
13926 if(!isWasmInitialized) {
13927 throw new Error("initializeWasm() must be awaited first!");
13929 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
13930 return nativeResponseValue;
13932 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
13934 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
13935 if(!isWasmInitialized) {
13936 throw new Error("initializeWasm() must be awaited first!");
13938 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
13939 return nativeResponseValue;
13941 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
13943 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
13944 if(!isWasmInitialized) {
13945 throw new Error("initializeWasm() must be awaited first!");
13947 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
13948 return nativeResponseValue;
13950 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
13952 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
13953 if(!isWasmInitialized) {
13954 throw new Error("initializeWasm() must be awaited first!");
13956 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
13957 // debug statements here
13959 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
13961 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
13962 if(!isWasmInitialized) {
13963 throw new Error("initializeWasm() must be awaited first!");
13965 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
13966 return nativeResponseValue;
13968 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
13970 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
13971 if(!isWasmInitialized) {
13972 throw new Error("initializeWasm() must be awaited first!");
13974 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
13975 return nativeResponseValue;
13977 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
13979 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
13980 if(!isWasmInitialized) {
13981 throw new Error("initializeWasm() must be awaited first!");
13983 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13984 return nativeResponseValue;
13986 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13988 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
13989 if(!isWasmInitialized) {
13990 throw new Error("initializeWasm() must be awaited first!");
13992 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13993 // debug statements here
13995 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13997 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13998 if(!isWasmInitialized) {
13999 throw new Error("initializeWasm() must be awaited first!");
14001 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
14002 // debug statements here
14004 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
14006 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
14007 if(!isWasmInitialized) {
14008 throw new Error("initializeWasm() must be awaited first!");
14010 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
14011 return nativeResponseValue;
14013 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
14015 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
14016 if(!isWasmInitialized) {
14017 throw new Error("initializeWasm() must be awaited first!");
14019 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
14020 return nativeResponseValue;
14022 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
14024 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
14025 if(!isWasmInitialized) {
14026 throw new Error("initializeWasm() must be awaited first!");
14028 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
14029 return nativeResponseValue;
14031 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
14033 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
14034 if(!isWasmInitialized) {
14035 throw new Error("initializeWasm() must be awaited first!");
14037 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
14038 // debug statements here
14040 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
14042 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
14043 if(!isWasmInitialized) {
14044 throw new Error("initializeWasm() must be awaited first!");
14046 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
14047 // debug statements here
14049 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
14051 export function CVec_EventZ_free(_res: number): void {
14052 if(!isWasmInitialized) {
14053 throw new Error("initializeWasm() must be awaited first!");
14055 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
14056 // debug statements here
14058 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
14060 export function CVec_TransactionZ_free(_res: number): void {
14061 if(!isWasmInitialized) {
14062 throw new Error("initializeWasm() must be awaited first!");
14064 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
14065 // debug statements here
14067 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
14069 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
14070 if(!isWasmInitialized) {
14071 throw new Error("initializeWasm() must be awaited first!");
14073 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
14074 return nativeResponseValue;
14076 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
14078 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
14079 if(!isWasmInitialized) {
14080 throw new Error("initializeWasm() must be awaited first!");
14082 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
14083 return nativeResponseValue;
14085 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
14087 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
14088 if(!isWasmInitialized) {
14089 throw new Error("initializeWasm() must be awaited first!");
14091 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
14092 return nativeResponseValue;
14094 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
14096 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
14097 if(!isWasmInitialized) {
14098 throw new Error("initializeWasm() must be awaited first!");
14100 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
14101 // debug statements here
14103 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
14105 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
14106 if(!isWasmInitialized) {
14107 throw new Error("initializeWasm() must be awaited first!");
14109 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
14110 // debug statements here
14112 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
14114 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
14115 if(!isWasmInitialized) {
14116 throw new Error("initializeWasm() must be awaited first!");
14118 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
14119 return nativeResponseValue;
14121 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
14123 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
14124 if(!isWasmInitialized) {
14125 throw new Error("initializeWasm() must be awaited first!");
14127 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
14128 return nativeResponseValue;
14130 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
14132 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
14133 if(!isWasmInitialized) {
14134 throw new Error("initializeWasm() must be awaited first!");
14136 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
14137 return nativeResponseValue;
14139 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
14141 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
14142 if(!isWasmInitialized) {
14143 throw new Error("initializeWasm() must be awaited first!");
14145 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
14146 // debug statements here
14148 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
14150 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
14151 if(!isWasmInitialized) {
14152 throw new Error("initializeWasm() must be awaited first!");
14154 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
14155 // debug statements here
14157 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
14159 export function CVec_BalanceZ_free(_res: number): void {
14160 if(!isWasmInitialized) {
14161 throw new Error("initializeWasm() must be awaited first!");
14163 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
14164 // debug statements here
14166 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
14168 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
14169 if(!isWasmInitialized) {
14170 throw new Error("initializeWasm() must be awaited first!");
14172 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
14173 return nativeResponseValue;
14175 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
14177 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
14178 if(!isWasmInitialized) {
14179 throw new Error("initializeWasm() must be awaited first!");
14181 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
14182 return nativeResponseValue;
14184 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
14186 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
14187 if(!isWasmInitialized) {
14188 throw new Error("initializeWasm() must be awaited first!");
14190 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
14191 return nativeResponseValue;
14193 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
14195 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
14196 if(!isWasmInitialized) {
14197 throw new Error("initializeWasm() must be awaited first!");
14199 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
14200 // debug statements here
14202 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
14204 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
14205 if(!isWasmInitialized) {
14206 throw new Error("initializeWasm() must be awaited first!");
14208 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
14209 return nativeResponseValue;
14211 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
14213 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
14214 if(!isWasmInitialized) {
14215 throw new Error("initializeWasm() must be awaited first!");
14217 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
14218 return nativeResponseValue;
14220 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
14222 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
14223 if(!isWasmInitialized) {
14224 throw new Error("initializeWasm() must be awaited first!");
14226 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
14227 return nativeResponseValue;
14229 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
14231 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
14232 if(!isWasmInitialized) {
14233 throw new Error("initializeWasm() must be awaited first!");
14235 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
14236 // debug statements here
14238 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
14240 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14241 if(!isWasmInitialized) {
14242 throw new Error("initializeWasm() must be awaited first!");
14244 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
14245 return nativeResponseValue;
14247 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
14249 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
14250 if(!isWasmInitialized) {
14251 throw new Error("initializeWasm() must be awaited first!");
14253 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
14254 return nativeResponseValue;
14256 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
14258 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
14259 if(!isWasmInitialized) {
14260 throw new Error("initializeWasm() must be awaited first!");
14262 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
14263 return nativeResponseValue;
14265 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
14267 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
14268 if(!isWasmInitialized) {
14269 throw new Error("initializeWasm() must be awaited first!");
14271 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
14272 return nativeResponseValue;
14274 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
14276 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
14277 if(!isWasmInitialized) {
14278 throw new Error("initializeWasm() must be awaited first!");
14280 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
14281 return nativeResponseValue;
14283 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
14285 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
14286 if(!isWasmInitialized) {
14287 throw new Error("initializeWasm() must be awaited first!");
14289 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
14290 // debug statements here
14292 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
14294 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
14295 if(!isWasmInitialized) {
14296 throw new Error("initializeWasm() must be awaited first!");
14298 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
14299 // debug statements here
14301 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_some(struct LDKCustomOnionMessageContents o);
14303 export function COption_CustomOnionMessageContentsZ_some(o: bigint): bigint {
14304 if(!isWasmInitialized) {
14305 throw new Error("initializeWasm() must be awaited first!");
14307 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_some(o);
14308 return nativeResponseValue;
14310 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_none(void);
14312 export function COption_CustomOnionMessageContentsZ_none(): bigint {
14313 if(!isWasmInitialized) {
14314 throw new Error("initializeWasm() must be awaited first!");
14316 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_none();
14317 return nativeResponseValue;
14319 // void COption_CustomOnionMessageContentsZ_free(struct LDKCOption_CustomOnionMessageContentsZ _res);
14321 export function COption_CustomOnionMessageContentsZ_free(_res: bigint): void {
14322 if(!isWasmInitialized) {
14323 throw new Error("initializeWasm() must be awaited first!");
14325 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_free(_res);
14326 // debug statements here
14328 // uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg);
14330 export function COption_CustomOnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
14331 if(!isWasmInitialized) {
14332 throw new Error("initializeWasm() must be awaited first!");
14334 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone_ptr(arg);
14335 return nativeResponseValue;
14337 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_clone(const struct LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR orig);
14339 export function COption_CustomOnionMessageContentsZ_clone(orig: bigint): bigint {
14340 if(!isWasmInitialized) {
14341 throw new Error("initializeWasm() must be awaited first!");
14343 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone(orig);
14344 return nativeResponseValue;
14346 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_CustomOnionMessageContentsZ o);
14348 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
14349 if(!isWasmInitialized) {
14350 throw new Error("initializeWasm() must be awaited first!");
14352 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o);
14353 return nativeResponseValue;
14355 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
14357 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
14358 if(!isWasmInitialized) {
14359 throw new Error("initializeWasm() must be awaited first!");
14361 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e);
14362 return nativeResponseValue;
14364 // bool CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
14366 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
14367 if(!isWasmInitialized) {
14368 throw new Error("initializeWasm() must be awaited first!");
14370 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o);
14371 return nativeResponseValue;
14373 // void CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res);
14375 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
14376 if(!isWasmInitialized) {
14377 throw new Error("initializeWasm() must be awaited first!");
14379 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res);
14380 // debug statements here
14382 // uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
14384 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14385 if(!isWasmInitialized) {
14386 throw new Error("initializeWasm() must be awaited first!");
14388 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
14389 return nativeResponseValue;
14391 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
14393 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
14394 if(!isWasmInitialized) {
14395 throw new Error("initializeWasm() must be awaited first!");
14397 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig);
14398 return nativeResponseValue;
14400 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
14402 export function COption_NetAddressZ_some(o: bigint): bigint {
14403 if(!isWasmInitialized) {
14404 throw new Error("initializeWasm() must be awaited first!");
14406 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
14407 return nativeResponseValue;
14409 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
14411 export function COption_NetAddressZ_none(): bigint {
14412 if(!isWasmInitialized) {
14413 throw new Error("initializeWasm() must be awaited first!");
14415 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
14416 return nativeResponseValue;
14418 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
14420 export function COption_NetAddressZ_free(_res: bigint): void {
14421 if(!isWasmInitialized) {
14422 throw new Error("initializeWasm() must be awaited first!");
14424 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
14425 // debug statements here
14427 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
14429 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
14430 if(!isWasmInitialized) {
14431 throw new Error("initializeWasm() must be awaited first!");
14433 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
14434 return nativeResponseValue;
14436 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
14438 export function COption_NetAddressZ_clone(orig: bigint): bigint {
14439 if(!isWasmInitialized) {
14440 throw new Error("initializeWasm() must be awaited first!");
14442 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
14443 return nativeResponseValue;
14445 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
14447 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
14448 if(!isWasmInitialized) {
14449 throw new Error("initializeWasm() must be awaited first!");
14451 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
14452 return nativeResponseValue;
14454 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14456 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
14457 if(!isWasmInitialized) {
14458 throw new Error("initializeWasm() must be awaited first!");
14460 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
14461 return nativeResponseValue;
14463 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
14465 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
14466 if(!isWasmInitialized) {
14467 throw new Error("initializeWasm() must be awaited first!");
14469 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
14470 return nativeResponseValue;
14472 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
14474 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
14475 if(!isWasmInitialized) {
14476 throw new Error("initializeWasm() must be awaited first!");
14478 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
14479 // debug statements here
14481 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
14483 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14484 if(!isWasmInitialized) {
14485 throw new Error("initializeWasm() must be awaited first!");
14487 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
14488 return nativeResponseValue;
14490 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
14492 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
14493 if(!isWasmInitialized) {
14494 throw new Error("initializeWasm() must be awaited first!");
14496 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
14497 return nativeResponseValue;
14499 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
14501 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
14502 if(!isWasmInitialized) {
14503 throw new Error("initializeWasm() must be awaited first!");
14505 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
14506 return nativeResponseValue;
14508 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
14510 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
14511 if(!isWasmInitialized) {
14512 throw new Error("initializeWasm() must be awaited first!");
14514 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
14515 return nativeResponseValue;
14517 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
14519 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
14520 if(!isWasmInitialized) {
14521 throw new Error("initializeWasm() must be awaited first!");
14523 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
14524 return nativeResponseValue;
14526 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
14528 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
14529 if(!isWasmInitialized) {
14530 throw new Error("initializeWasm() must be awaited first!");
14532 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
14533 // debug statements here
14535 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
14537 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14538 if(!isWasmInitialized) {
14539 throw new Error("initializeWasm() must be awaited first!");
14541 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
14542 return nativeResponseValue;
14544 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
14546 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
14547 if(!isWasmInitialized) {
14548 throw new Error("initializeWasm() must be awaited first!");
14550 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
14551 return nativeResponseValue;
14553 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
14555 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
14556 if(!isWasmInitialized) {
14557 throw new Error("initializeWasm() must be awaited first!");
14559 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
14560 return nativeResponseValue;
14562 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
14564 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
14565 if(!isWasmInitialized) {
14566 throw new Error("initializeWasm() must be awaited first!");
14568 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
14569 return nativeResponseValue;
14571 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
14573 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
14574 if(!isWasmInitialized) {
14575 throw new Error("initializeWasm() must be awaited first!");
14577 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
14578 return nativeResponseValue;
14580 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
14582 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
14583 if(!isWasmInitialized) {
14584 throw new Error("initializeWasm() must be awaited first!");
14586 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
14587 // debug statements here
14589 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
14591 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
14592 if(!isWasmInitialized) {
14593 throw new Error("initializeWasm() must be awaited first!");
14595 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
14596 return nativeResponseValue;
14598 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
14600 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
14601 if(!isWasmInitialized) {
14602 throw new Error("initializeWasm() must be awaited first!");
14604 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
14605 return nativeResponseValue;
14607 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
14609 export function CResult_NoneSendErrorZ_ok(): bigint {
14610 if(!isWasmInitialized) {
14611 throw new Error("initializeWasm() must be awaited first!");
14613 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
14614 return nativeResponseValue;
14616 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
14618 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
14619 if(!isWasmInitialized) {
14620 throw new Error("initializeWasm() must be awaited first!");
14622 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
14623 return nativeResponseValue;
14625 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
14627 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
14628 if(!isWasmInitialized) {
14629 throw new Error("initializeWasm() must be awaited first!");
14631 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
14632 return nativeResponseValue;
14634 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
14636 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
14637 if(!isWasmInitialized) {
14638 throw new Error("initializeWasm() must be awaited first!");
14640 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
14641 // debug statements here
14643 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
14645 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
14646 if(!isWasmInitialized) {
14647 throw new Error("initializeWasm() must be awaited first!");
14649 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
14650 return nativeResponseValue;
14652 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
14654 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
14655 if(!isWasmInitialized) {
14656 throw new Error("initializeWasm() must be awaited first!");
14658 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
14659 return nativeResponseValue;
14661 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
14663 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
14664 if(!isWasmInitialized) {
14665 throw new Error("initializeWasm() must be awaited first!");
14667 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
14668 return nativeResponseValue;
14670 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
14672 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
14673 if(!isWasmInitialized) {
14674 throw new Error("initializeWasm() must be awaited first!");
14676 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
14677 // debug statements here
14679 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
14681 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
14682 if(!isWasmInitialized) {
14683 throw new Error("initializeWasm() must be awaited first!");
14685 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
14686 return nativeResponseValue;
14688 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
14690 export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
14691 if(!isWasmInitialized) {
14692 throw new Error("initializeWasm() must be awaited first!");
14694 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
14695 return nativeResponseValue;
14697 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
14699 export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
14700 if(!isWasmInitialized) {
14701 throw new Error("initializeWasm() must be awaited first!");
14703 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
14704 return nativeResponseValue;
14706 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
14708 export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
14709 if(!isWasmInitialized) {
14710 throw new Error("initializeWasm() must be awaited first!");
14712 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
14713 // debug statements here
14715 // uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
14717 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
14718 if(!isWasmInitialized) {
14719 throw new Error("initializeWasm() must be awaited first!");
14721 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
14722 return nativeResponseValue;
14724 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
14726 export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
14727 if(!isWasmInitialized) {
14728 throw new Error("initializeWasm() must be awaited first!");
14730 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
14731 return nativeResponseValue;
14733 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
14735 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
14736 if(!isWasmInitialized) {
14737 throw new Error("initializeWasm() must be awaited first!");
14739 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
14740 return nativeResponseValue;
14742 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
14744 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
14745 if(!isWasmInitialized) {
14746 throw new Error("initializeWasm() must be awaited first!");
14748 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
14749 return nativeResponseValue;
14751 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
14753 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
14754 if(!isWasmInitialized) {
14755 throw new Error("initializeWasm() must be awaited first!");
14757 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
14758 return nativeResponseValue;
14760 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
14762 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
14763 if(!isWasmInitialized) {
14764 throw new Error("initializeWasm() must be awaited first!");
14766 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
14767 // debug statements here
14769 // uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
14771 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
14772 if(!isWasmInitialized) {
14773 throw new Error("initializeWasm() must be awaited first!");
14775 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
14776 return nativeResponseValue;
14778 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
14780 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
14781 if(!isWasmInitialized) {
14782 throw new Error("initializeWasm() must be awaited first!");
14784 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
14785 return nativeResponseValue;
14787 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
14789 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
14790 if(!isWasmInitialized) {
14791 throw new Error("initializeWasm() must be awaited first!");
14793 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
14794 return nativeResponseValue;
14796 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
14798 export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
14799 if(!isWasmInitialized) {
14800 throw new Error("initializeWasm() must be awaited first!");
14802 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
14803 return nativeResponseValue;
14805 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
14807 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
14808 if(!isWasmInitialized) {
14809 throw new Error("initializeWasm() must be awaited first!");
14811 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
14812 return nativeResponseValue;
14814 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
14816 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
14817 if(!isWasmInitialized) {
14818 throw new Error("initializeWasm() must be awaited first!");
14820 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
14821 // debug statements here
14823 // uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
14825 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
14826 if(!isWasmInitialized) {
14827 throw new Error("initializeWasm() must be awaited first!");
14829 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
14830 return nativeResponseValue;
14832 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
14834 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
14835 if(!isWasmInitialized) {
14836 throw new Error("initializeWasm() must be awaited first!");
14838 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
14839 return nativeResponseValue;
14841 // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
14843 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
14844 if(!isWasmInitialized) {
14845 throw new Error("initializeWasm() must be awaited first!");
14847 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
14848 return nativeResponseValue;
14850 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
14852 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
14853 if(!isWasmInitialized) {
14854 throw new Error("initializeWasm() must be awaited first!");
14856 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
14857 return nativeResponseValue;
14859 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
14861 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
14862 if(!isWasmInitialized) {
14863 throw new Error("initializeWasm() must be awaited first!");
14865 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
14866 return nativeResponseValue;
14868 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
14870 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
14871 if(!isWasmInitialized) {
14872 throw new Error("initializeWasm() must be awaited first!");
14874 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
14875 // debug statements here
14877 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
14879 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
14880 if(!isWasmInitialized) {
14881 throw new Error("initializeWasm() must be awaited first!");
14883 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
14884 return nativeResponseValue;
14886 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
14888 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
14889 if(!isWasmInitialized) {
14890 throw new Error("initializeWasm() must be awaited first!");
14892 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
14893 return nativeResponseValue;
14895 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
14897 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
14898 if(!isWasmInitialized) {
14899 throw new Error("initializeWasm() must be awaited first!");
14901 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
14902 return nativeResponseValue;
14904 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
14906 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
14907 if(!isWasmInitialized) {
14908 throw new Error("initializeWasm() must be awaited first!");
14910 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
14911 // debug statements here
14913 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
14915 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
14916 if(!isWasmInitialized) {
14917 throw new Error("initializeWasm() must be awaited first!");
14919 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
14920 return nativeResponseValue;
14922 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
14924 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
14925 if(!isWasmInitialized) {
14926 throw new Error("initializeWasm() must be awaited first!");
14928 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
14929 return nativeResponseValue;
14931 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
14933 export function CVec_PrivateRouteZ_free(_res: number): void {
14934 if(!isWasmInitialized) {
14935 throw new Error("initializeWasm() must be awaited first!");
14937 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
14938 // debug statements here
14940 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
14942 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
14943 if(!isWasmInitialized) {
14944 throw new Error("initializeWasm() must be awaited first!");
14946 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
14947 return nativeResponseValue;
14949 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
14951 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
14952 if(!isWasmInitialized) {
14953 throw new Error("initializeWasm() must be awaited first!");
14955 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
14956 return nativeResponseValue;
14958 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
14960 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
14961 if(!isWasmInitialized) {
14962 throw new Error("initializeWasm() must be awaited first!");
14964 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
14965 return nativeResponseValue;
14967 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
14969 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
14970 if(!isWasmInitialized) {
14971 throw new Error("initializeWasm() must be awaited first!");
14973 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
14974 // debug statements here
14976 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
14978 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
14979 if(!isWasmInitialized) {
14980 throw new Error("initializeWasm() must be awaited first!");
14982 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
14983 return nativeResponseValue;
14985 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
14987 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
14988 if(!isWasmInitialized) {
14989 throw new Error("initializeWasm() must be awaited first!");
14991 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
14992 return nativeResponseValue;
14994 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
14996 export function CResult_NoneSemanticErrorZ_ok(): bigint {
14997 if(!isWasmInitialized) {
14998 throw new Error("initializeWasm() must be awaited first!");
15000 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
15001 return nativeResponseValue;
15003 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
15005 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
15006 if(!isWasmInitialized) {
15007 throw new Error("initializeWasm() must be awaited first!");
15009 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
15010 return nativeResponseValue;
15012 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
15014 export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
15015 if(!isWasmInitialized) {
15016 throw new Error("initializeWasm() must be awaited first!");
15018 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
15019 return nativeResponseValue;
15021 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
15023 export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
15024 if(!isWasmInitialized) {
15025 throw new Error("initializeWasm() must be awaited first!");
15027 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
15028 // debug statements here
15030 // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
15032 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
15033 if(!isWasmInitialized) {
15034 throw new Error("initializeWasm() must be awaited first!");
15036 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
15037 return nativeResponseValue;
15039 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
15041 export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
15042 if(!isWasmInitialized) {
15043 throw new Error("initializeWasm() must be awaited first!");
15045 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
15046 return nativeResponseValue;
15048 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
15050 export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
15051 if(!isWasmInitialized) {
15052 throw new Error("initializeWasm() must be awaited first!");
15054 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
15055 return nativeResponseValue;
15057 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
15059 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
15060 if(!isWasmInitialized) {
15061 throw new Error("initializeWasm() must be awaited first!");
15063 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
15064 return nativeResponseValue;
15066 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
15068 export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
15069 if(!isWasmInitialized) {
15070 throw new Error("initializeWasm() must be awaited first!");
15072 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
15073 return nativeResponseValue;
15075 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
15077 export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
15078 if(!isWasmInitialized) {
15079 throw new Error("initializeWasm() must be awaited first!");
15081 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
15082 // debug statements here
15084 // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
15086 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
15087 if(!isWasmInitialized) {
15088 throw new Error("initializeWasm() must be awaited first!");
15090 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
15091 return nativeResponseValue;
15093 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
15095 export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
15096 if(!isWasmInitialized) {
15097 throw new Error("initializeWasm() must be awaited first!");
15099 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
15100 return nativeResponseValue;
15102 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
15104 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
15105 if(!isWasmInitialized) {
15106 throw new Error("initializeWasm() must be awaited first!");
15108 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
15109 return nativeResponseValue;
15111 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
15113 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
15114 if(!isWasmInitialized) {
15115 throw new Error("initializeWasm() must be awaited first!");
15117 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
15118 return nativeResponseValue;
15120 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
15122 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
15123 if(!isWasmInitialized) {
15124 throw new Error("initializeWasm() must be awaited first!");
15126 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
15127 return nativeResponseValue;
15129 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
15131 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
15132 if(!isWasmInitialized) {
15133 throw new Error("initializeWasm() must be awaited first!");
15135 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
15136 // debug statements here
15138 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
15140 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
15141 if(!isWasmInitialized) {
15142 throw new Error("initializeWasm() must be awaited first!");
15144 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
15145 return nativeResponseValue;
15147 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
15149 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
15150 if(!isWasmInitialized) {
15151 throw new Error("initializeWasm() must be awaited first!");
15153 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
15154 return nativeResponseValue;
15156 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
15158 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
15159 if(!isWasmInitialized) {
15160 throw new Error("initializeWasm() must be awaited first!");
15162 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
15163 return nativeResponseValue;
15165 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
15167 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
15168 if(!isWasmInitialized) {
15169 throw new Error("initializeWasm() must be awaited first!");
15171 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
15172 return nativeResponseValue;
15174 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
15176 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
15177 if(!isWasmInitialized) {
15178 throw new Error("initializeWasm() must be awaited first!");
15180 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
15181 return nativeResponseValue;
15183 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
15185 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
15186 if(!isWasmInitialized) {
15187 throw new Error("initializeWasm() must be awaited first!");
15189 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
15190 // debug statements here
15192 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
15194 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
15195 if(!isWasmInitialized) {
15196 throw new Error("initializeWasm() must be awaited first!");
15198 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
15199 return nativeResponseValue;
15201 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
15203 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
15204 if(!isWasmInitialized) {
15205 throw new Error("initializeWasm() must be awaited first!");
15207 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
15208 return nativeResponseValue;
15210 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
15212 export function CResult_NoneErrorZ_ok(): bigint {
15213 if(!isWasmInitialized) {
15214 throw new Error("initializeWasm() must be awaited first!");
15216 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
15217 return nativeResponseValue;
15219 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
15221 export function CResult_NoneErrorZ_err(e: IOError): bigint {
15222 if(!isWasmInitialized) {
15223 throw new Error("initializeWasm() must be awaited first!");
15225 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
15226 return nativeResponseValue;
15228 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
15230 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
15231 if(!isWasmInitialized) {
15232 throw new Error("initializeWasm() must be awaited first!");
15234 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
15235 return nativeResponseValue;
15237 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
15239 export function CResult_NoneErrorZ_free(_res: bigint): void {
15240 if(!isWasmInitialized) {
15241 throw new Error("initializeWasm() must be awaited first!");
15243 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
15244 // debug statements here
15246 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
15248 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
15249 if(!isWasmInitialized) {
15250 throw new Error("initializeWasm() must be awaited first!");
15252 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
15253 return nativeResponseValue;
15255 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
15257 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
15258 if(!isWasmInitialized) {
15259 throw new Error("initializeWasm() must be awaited first!");
15261 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
15262 return nativeResponseValue;
15264 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
15266 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
15267 if(!isWasmInitialized) {
15268 throw new Error("initializeWasm() must be awaited first!");
15270 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
15271 return nativeResponseValue;
15273 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
15275 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
15276 if(!isWasmInitialized) {
15277 throw new Error("initializeWasm() must be awaited first!");
15279 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
15280 return nativeResponseValue;
15282 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
15284 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
15285 if(!isWasmInitialized) {
15286 throw new Error("initializeWasm() must be awaited first!");
15288 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
15289 return nativeResponseValue;
15291 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
15293 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
15294 if(!isWasmInitialized) {
15295 throw new Error("initializeWasm() must be awaited first!");
15297 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
15298 // debug statements here
15300 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
15302 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15303 if(!isWasmInitialized) {
15304 throw new Error("initializeWasm() must be awaited first!");
15306 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
15307 return nativeResponseValue;
15309 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
15311 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
15312 if(!isWasmInitialized) {
15313 throw new Error("initializeWasm() must be awaited first!");
15315 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
15316 return nativeResponseValue;
15318 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
15320 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
15321 if(!isWasmInitialized) {
15322 throw new Error("initializeWasm() must be awaited first!");
15324 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
15325 // debug statements here
15327 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
15329 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
15330 if(!isWasmInitialized) {
15331 throw new Error("initializeWasm() must be awaited first!");
15333 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
15334 // debug statements here
15336 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
15338 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
15339 if(!isWasmInitialized) {
15340 throw new Error("initializeWasm() must be awaited first!");
15342 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
15343 // debug statements here
15345 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
15347 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
15348 if(!isWasmInitialized) {
15349 throw new Error("initializeWasm() must be awaited first!");
15351 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
15352 // debug statements here
15354 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
15356 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
15357 if(!isWasmInitialized) {
15358 throw new Error("initializeWasm() must be awaited first!");
15360 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
15361 return nativeResponseValue;
15363 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
15365 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
15366 if(!isWasmInitialized) {
15367 throw new Error("initializeWasm() must be awaited first!");
15369 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
15370 return nativeResponseValue;
15372 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
15374 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
15375 if(!isWasmInitialized) {
15376 throw new Error("initializeWasm() must be awaited first!");
15378 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
15379 return nativeResponseValue;
15381 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
15383 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
15384 if(!isWasmInitialized) {
15385 throw new Error("initializeWasm() must be awaited first!");
15387 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
15388 // debug statements here
15390 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
15392 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15393 if(!isWasmInitialized) {
15394 throw new Error("initializeWasm() must be awaited first!");
15396 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
15397 return nativeResponseValue;
15399 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
15401 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
15402 if(!isWasmInitialized) {
15403 throw new Error("initializeWasm() must be awaited first!");
15405 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
15406 return nativeResponseValue;
15408 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
15410 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
15411 if(!isWasmInitialized) {
15412 throw new Error("initializeWasm() must be awaited first!");
15414 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
15415 return nativeResponseValue;
15417 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
15419 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
15420 if(!isWasmInitialized) {
15421 throw new Error("initializeWasm() must be awaited first!");
15423 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
15424 return nativeResponseValue;
15426 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
15428 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15429 if(!isWasmInitialized) {
15430 throw new Error("initializeWasm() must be awaited first!");
15432 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
15433 return nativeResponseValue;
15435 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
15437 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
15438 if(!isWasmInitialized) {
15439 throw new Error("initializeWasm() must be awaited first!");
15441 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
15442 // debug statements here
15444 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
15446 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15447 if(!isWasmInitialized) {
15448 throw new Error("initializeWasm() must be awaited first!");
15450 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
15451 return nativeResponseValue;
15453 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
15455 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
15456 if(!isWasmInitialized) {
15457 throw new Error("initializeWasm() must be awaited first!");
15459 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
15460 return nativeResponseValue;
15462 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
15464 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
15465 if(!isWasmInitialized) {
15466 throw new Error("initializeWasm() must be awaited first!");
15468 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
15469 return nativeResponseValue;
15471 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
15473 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
15474 if(!isWasmInitialized) {
15475 throw new Error("initializeWasm() must be awaited first!");
15477 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
15478 return nativeResponseValue;
15480 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
15482 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
15483 if(!isWasmInitialized) {
15484 throw new Error("initializeWasm() must be awaited first!");
15486 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
15487 return nativeResponseValue;
15489 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
15491 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
15492 if(!isWasmInitialized) {
15493 throw new Error("initializeWasm() must be awaited first!");
15495 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
15496 // debug statements here
15498 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
15500 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15501 if(!isWasmInitialized) {
15502 throw new Error("initializeWasm() must be awaited first!");
15504 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
15505 return nativeResponseValue;
15507 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
15509 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
15510 if(!isWasmInitialized) {
15511 throw new Error("initializeWasm() must be awaited first!");
15513 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
15514 return nativeResponseValue;
15516 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
15518 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
15519 if(!isWasmInitialized) {
15520 throw new Error("initializeWasm() must be awaited first!");
15522 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
15523 return nativeResponseValue;
15525 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
15527 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
15528 if(!isWasmInitialized) {
15529 throw new Error("initializeWasm() must be awaited first!");
15531 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
15532 return nativeResponseValue;
15534 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
15536 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
15537 if(!isWasmInitialized) {
15538 throw new Error("initializeWasm() must be awaited first!");
15540 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
15541 return nativeResponseValue;
15543 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
15545 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
15546 if(!isWasmInitialized) {
15547 throw new Error("initializeWasm() must be awaited first!");
15549 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
15550 // debug statements here
15552 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
15554 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15555 if(!isWasmInitialized) {
15556 throw new Error("initializeWasm() must be awaited first!");
15558 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
15559 return nativeResponseValue;
15561 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
15563 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
15564 if(!isWasmInitialized) {
15565 throw new Error("initializeWasm() must be awaited first!");
15567 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
15568 return nativeResponseValue;
15570 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
15572 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
15573 if(!isWasmInitialized) {
15574 throw new Error("initializeWasm() must be awaited first!");
15576 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
15577 return nativeResponseValue;
15579 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
15581 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
15582 if(!isWasmInitialized) {
15583 throw new Error("initializeWasm() must be awaited first!");
15585 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
15586 return nativeResponseValue;
15588 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
15590 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
15591 if(!isWasmInitialized) {
15592 throw new Error("initializeWasm() must be awaited first!");
15594 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
15595 return nativeResponseValue;
15597 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
15599 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
15600 if(!isWasmInitialized) {
15601 throw new Error("initializeWasm() must be awaited first!");
15603 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
15604 // debug statements here
15606 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
15608 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15609 if(!isWasmInitialized) {
15610 throw new Error("initializeWasm() must be awaited first!");
15612 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
15613 return nativeResponseValue;
15615 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
15617 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
15618 if(!isWasmInitialized) {
15619 throw new Error("initializeWasm() must be awaited first!");
15621 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
15622 return nativeResponseValue;
15624 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
15626 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
15627 if(!isWasmInitialized) {
15628 throw new Error("initializeWasm() must be awaited first!");
15630 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
15631 return nativeResponseValue;
15633 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
15635 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
15636 if(!isWasmInitialized) {
15637 throw new Error("initializeWasm() must be awaited first!");
15639 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
15640 return nativeResponseValue;
15642 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
15644 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
15645 if(!isWasmInitialized) {
15646 throw new Error("initializeWasm() must be awaited first!");
15648 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
15649 return nativeResponseValue;
15651 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
15653 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
15654 if(!isWasmInitialized) {
15655 throw new Error("initializeWasm() must be awaited first!");
15657 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
15658 // debug statements here
15660 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
15662 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15663 if(!isWasmInitialized) {
15664 throw new Error("initializeWasm() must be awaited first!");
15666 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
15667 return nativeResponseValue;
15669 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
15671 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
15672 if(!isWasmInitialized) {
15673 throw new Error("initializeWasm() must be awaited first!");
15675 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
15676 return nativeResponseValue;
15678 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
15680 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
15681 if(!isWasmInitialized) {
15682 throw new Error("initializeWasm() must be awaited first!");
15684 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
15685 return nativeResponseValue;
15687 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
15689 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
15690 if(!isWasmInitialized) {
15691 throw new Error("initializeWasm() must be awaited first!");
15693 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
15694 return nativeResponseValue;
15696 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
15698 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
15699 if(!isWasmInitialized) {
15700 throw new Error("initializeWasm() must be awaited first!");
15702 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
15703 return nativeResponseValue;
15705 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
15707 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
15708 if(!isWasmInitialized) {
15709 throw new Error("initializeWasm() must be awaited first!");
15711 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
15712 // debug statements here
15714 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
15716 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15717 if(!isWasmInitialized) {
15718 throw new Error("initializeWasm() must be awaited first!");
15720 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
15721 return nativeResponseValue;
15723 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
15725 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
15726 if(!isWasmInitialized) {
15727 throw new Error("initializeWasm() must be awaited first!");
15729 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
15730 return nativeResponseValue;
15732 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
15734 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
15735 if(!isWasmInitialized) {
15736 throw new Error("initializeWasm() must be awaited first!");
15738 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
15739 return nativeResponseValue;
15741 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
15743 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
15744 if(!isWasmInitialized) {
15745 throw new Error("initializeWasm() must be awaited first!");
15747 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
15748 return nativeResponseValue;
15750 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
15752 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
15753 if(!isWasmInitialized) {
15754 throw new Error("initializeWasm() must be awaited first!");
15756 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
15757 return nativeResponseValue;
15759 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
15761 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
15762 if(!isWasmInitialized) {
15763 throw new Error("initializeWasm() must be awaited first!");
15765 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
15766 // debug statements here
15768 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
15770 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15771 if(!isWasmInitialized) {
15772 throw new Error("initializeWasm() must be awaited first!");
15774 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
15775 return nativeResponseValue;
15777 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
15779 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
15780 if(!isWasmInitialized) {
15781 throw new Error("initializeWasm() must be awaited first!");
15783 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
15784 return nativeResponseValue;
15786 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
15788 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
15789 if(!isWasmInitialized) {
15790 throw new Error("initializeWasm() must be awaited first!");
15792 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
15793 return nativeResponseValue;
15795 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
15797 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
15798 if(!isWasmInitialized) {
15799 throw new Error("initializeWasm() must be awaited first!");
15801 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
15802 return nativeResponseValue;
15804 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
15806 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
15807 if(!isWasmInitialized) {
15808 throw new Error("initializeWasm() must be awaited first!");
15810 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
15811 return nativeResponseValue;
15813 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
15815 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
15816 if(!isWasmInitialized) {
15817 throw new Error("initializeWasm() must be awaited first!");
15819 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
15820 // debug statements here
15822 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
15824 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15825 if(!isWasmInitialized) {
15826 throw new Error("initializeWasm() must be awaited first!");
15828 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
15829 return nativeResponseValue;
15831 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
15833 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
15834 if(!isWasmInitialized) {
15835 throw new Error("initializeWasm() must be awaited first!");
15837 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
15838 return nativeResponseValue;
15840 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
15842 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
15843 if(!isWasmInitialized) {
15844 throw new Error("initializeWasm() must be awaited first!");
15846 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
15847 return nativeResponseValue;
15849 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
15851 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
15852 if(!isWasmInitialized) {
15853 throw new Error("initializeWasm() must be awaited first!");
15855 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
15856 return nativeResponseValue;
15858 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
15860 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
15861 if(!isWasmInitialized) {
15862 throw new Error("initializeWasm() must be awaited first!");
15864 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
15865 return nativeResponseValue;
15867 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
15869 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
15870 if(!isWasmInitialized) {
15871 throw new Error("initializeWasm() must be awaited first!");
15873 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
15874 // debug statements here
15876 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
15878 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15879 if(!isWasmInitialized) {
15880 throw new Error("initializeWasm() must be awaited first!");
15882 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
15883 return nativeResponseValue;
15885 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
15887 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
15888 if(!isWasmInitialized) {
15889 throw new Error("initializeWasm() must be awaited first!");
15891 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
15892 return nativeResponseValue;
15894 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
15896 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
15897 if(!isWasmInitialized) {
15898 throw new Error("initializeWasm() must be awaited first!");
15900 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
15901 return nativeResponseValue;
15903 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
15905 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
15906 if(!isWasmInitialized) {
15907 throw new Error("initializeWasm() must be awaited first!");
15909 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
15910 return nativeResponseValue;
15912 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
15914 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
15915 if(!isWasmInitialized) {
15916 throw new Error("initializeWasm() must be awaited first!");
15918 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
15919 return nativeResponseValue;
15921 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
15923 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
15924 if(!isWasmInitialized) {
15925 throw new Error("initializeWasm() must be awaited first!");
15927 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
15928 // debug statements here
15930 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
15932 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15933 if(!isWasmInitialized) {
15934 throw new Error("initializeWasm() must be awaited first!");
15936 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
15937 return nativeResponseValue;
15939 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
15941 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
15942 if(!isWasmInitialized) {
15943 throw new Error("initializeWasm() must be awaited first!");
15945 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
15946 return nativeResponseValue;
15948 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
15950 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
15951 if(!isWasmInitialized) {
15952 throw new Error("initializeWasm() must be awaited first!");
15954 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
15955 return nativeResponseValue;
15957 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
15959 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
15960 if(!isWasmInitialized) {
15961 throw new Error("initializeWasm() must be awaited first!");
15963 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
15964 return nativeResponseValue;
15966 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
15968 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
15969 if(!isWasmInitialized) {
15970 throw new Error("initializeWasm() must be awaited first!");
15972 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
15973 return nativeResponseValue;
15975 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
15977 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
15978 if(!isWasmInitialized) {
15979 throw new Error("initializeWasm() must be awaited first!");
15981 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
15982 // debug statements here
15984 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
15986 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15987 if(!isWasmInitialized) {
15988 throw new Error("initializeWasm() must be awaited first!");
15990 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
15991 return nativeResponseValue;
15993 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
15995 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
15996 if(!isWasmInitialized) {
15997 throw new Error("initializeWasm() must be awaited first!");
15999 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
16000 return nativeResponseValue;
16002 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
16004 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
16005 if(!isWasmInitialized) {
16006 throw new Error("initializeWasm() must be awaited first!");
16008 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
16009 return nativeResponseValue;
16011 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
16013 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
16014 if(!isWasmInitialized) {
16015 throw new Error("initializeWasm() must be awaited first!");
16017 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
16018 return nativeResponseValue;
16020 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
16022 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
16023 if(!isWasmInitialized) {
16024 throw new Error("initializeWasm() must be awaited first!");
16026 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
16027 return nativeResponseValue;
16029 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
16031 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
16032 if(!isWasmInitialized) {
16033 throw new Error("initializeWasm() must be awaited first!");
16035 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
16036 // debug statements here
16038 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
16040 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16041 if(!isWasmInitialized) {
16042 throw new Error("initializeWasm() must be awaited first!");
16044 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
16045 return nativeResponseValue;
16047 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
16049 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
16050 if(!isWasmInitialized) {
16051 throw new Error("initializeWasm() must be awaited first!");
16053 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
16054 return nativeResponseValue;
16056 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
16058 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
16059 if(!isWasmInitialized) {
16060 throw new Error("initializeWasm() must be awaited first!");
16062 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
16063 return nativeResponseValue;
16065 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16067 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
16068 if(!isWasmInitialized) {
16069 throw new Error("initializeWasm() must be awaited first!");
16071 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
16072 return nativeResponseValue;
16074 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
16076 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16077 if(!isWasmInitialized) {
16078 throw new Error("initializeWasm() must be awaited first!");
16080 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
16081 return nativeResponseValue;
16083 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
16085 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
16086 if(!isWasmInitialized) {
16087 throw new Error("initializeWasm() must be awaited first!");
16089 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
16090 // debug statements here
16092 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
16094 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16095 if(!isWasmInitialized) {
16096 throw new Error("initializeWasm() must be awaited first!");
16098 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
16099 return nativeResponseValue;
16101 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
16103 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16104 if(!isWasmInitialized) {
16105 throw new Error("initializeWasm() must be awaited first!");
16107 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
16108 return nativeResponseValue;
16110 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
16112 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
16113 if(!isWasmInitialized) {
16114 throw new Error("initializeWasm() must be awaited first!");
16116 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
16117 return nativeResponseValue;
16119 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16121 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
16122 if(!isWasmInitialized) {
16123 throw new Error("initializeWasm() must be awaited first!");
16125 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
16126 return nativeResponseValue;
16128 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
16130 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16131 if(!isWasmInitialized) {
16132 throw new Error("initializeWasm() must be awaited first!");
16134 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
16135 return nativeResponseValue;
16137 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
16139 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
16140 if(!isWasmInitialized) {
16141 throw new Error("initializeWasm() must be awaited first!");
16143 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
16144 // debug statements here
16146 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
16148 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16149 if(!isWasmInitialized) {
16150 throw new Error("initializeWasm() must be awaited first!");
16152 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
16153 return nativeResponseValue;
16155 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
16157 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16158 if(!isWasmInitialized) {
16159 throw new Error("initializeWasm() must be awaited first!");
16161 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
16162 return nativeResponseValue;
16164 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
16166 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
16167 if(!isWasmInitialized) {
16168 throw new Error("initializeWasm() must be awaited first!");
16170 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
16171 return nativeResponseValue;
16173 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
16175 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
16176 if(!isWasmInitialized) {
16177 throw new Error("initializeWasm() must be awaited first!");
16179 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
16180 return nativeResponseValue;
16182 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
16184 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
16185 if(!isWasmInitialized) {
16186 throw new Error("initializeWasm() must be awaited first!");
16188 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
16189 return nativeResponseValue;
16191 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
16193 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
16194 if(!isWasmInitialized) {
16195 throw new Error("initializeWasm() must be awaited first!");
16197 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
16198 // debug statements here
16200 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
16202 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16203 if(!isWasmInitialized) {
16204 throw new Error("initializeWasm() must be awaited first!");
16206 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
16207 return nativeResponseValue;
16209 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
16211 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
16212 if(!isWasmInitialized) {
16213 throw new Error("initializeWasm() must be awaited first!");
16215 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
16216 return nativeResponseValue;
16218 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
16220 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
16221 if(!isWasmInitialized) {
16222 throw new Error("initializeWasm() must be awaited first!");
16224 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
16225 return nativeResponseValue;
16227 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16229 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
16230 if(!isWasmInitialized) {
16231 throw new Error("initializeWasm() must be awaited first!");
16233 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
16234 return nativeResponseValue;
16236 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
16238 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16239 if(!isWasmInitialized) {
16240 throw new Error("initializeWasm() must be awaited first!");
16242 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
16243 return nativeResponseValue;
16245 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
16247 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
16248 if(!isWasmInitialized) {
16249 throw new Error("initializeWasm() must be awaited first!");
16251 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
16252 // debug statements here
16254 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
16256 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16257 if(!isWasmInitialized) {
16258 throw new Error("initializeWasm() must be awaited first!");
16260 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
16261 return nativeResponseValue;
16263 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
16265 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16266 if(!isWasmInitialized) {
16267 throw new Error("initializeWasm() must be awaited first!");
16269 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
16270 return nativeResponseValue;
16272 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
16274 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
16275 if(!isWasmInitialized) {
16276 throw new Error("initializeWasm() must be awaited first!");
16278 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
16279 return nativeResponseValue;
16281 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
16283 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
16284 if(!isWasmInitialized) {
16285 throw new Error("initializeWasm() must be awaited first!");
16287 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
16288 return nativeResponseValue;
16290 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
16292 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
16293 if(!isWasmInitialized) {
16294 throw new Error("initializeWasm() must be awaited first!");
16296 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
16297 return nativeResponseValue;
16299 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
16301 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
16302 if(!isWasmInitialized) {
16303 throw new Error("initializeWasm() must be awaited first!");
16305 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
16306 // debug statements here
16308 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
16310 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16311 if(!isWasmInitialized) {
16312 throw new Error("initializeWasm() must be awaited first!");
16314 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
16315 return nativeResponseValue;
16317 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
16319 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
16320 if(!isWasmInitialized) {
16321 throw new Error("initializeWasm() must be awaited first!");
16323 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
16324 return nativeResponseValue;
16326 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
16328 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
16329 if(!isWasmInitialized) {
16330 throw new Error("initializeWasm() must be awaited first!");
16332 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
16333 return nativeResponseValue;
16335 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
16337 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
16338 if(!isWasmInitialized) {
16339 throw new Error("initializeWasm() must be awaited first!");
16341 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
16342 return nativeResponseValue;
16344 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
16346 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16347 if(!isWasmInitialized) {
16348 throw new Error("initializeWasm() must be awaited first!");
16350 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
16351 return nativeResponseValue;
16353 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
16355 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
16356 if(!isWasmInitialized) {
16357 throw new Error("initializeWasm() must be awaited first!");
16359 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
16360 // debug statements here
16362 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
16364 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16365 if(!isWasmInitialized) {
16366 throw new Error("initializeWasm() must be awaited first!");
16368 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
16369 return nativeResponseValue;
16371 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
16373 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
16374 if(!isWasmInitialized) {
16375 throw new Error("initializeWasm() must be awaited first!");
16377 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
16378 return nativeResponseValue;
16380 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
16382 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
16383 if(!isWasmInitialized) {
16384 throw new Error("initializeWasm() must be awaited first!");
16386 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
16387 return nativeResponseValue;
16389 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
16391 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
16392 if(!isWasmInitialized) {
16393 throw new Error("initializeWasm() must be awaited first!");
16395 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
16396 return nativeResponseValue;
16398 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
16400 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
16401 if(!isWasmInitialized) {
16402 throw new Error("initializeWasm() must be awaited first!");
16404 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
16405 return nativeResponseValue;
16407 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
16409 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
16410 if(!isWasmInitialized) {
16411 throw new Error("initializeWasm() must be awaited first!");
16413 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
16414 // debug statements here
16416 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
16418 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16419 if(!isWasmInitialized) {
16420 throw new Error("initializeWasm() must be awaited first!");
16422 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
16423 return nativeResponseValue;
16425 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
16427 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
16428 if(!isWasmInitialized) {
16429 throw new Error("initializeWasm() must be awaited first!");
16431 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
16432 return nativeResponseValue;
16434 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
16436 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
16437 if(!isWasmInitialized) {
16438 throw new Error("initializeWasm() must be awaited first!");
16440 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
16441 return nativeResponseValue;
16443 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
16445 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
16446 if(!isWasmInitialized) {
16447 throw new Error("initializeWasm() must be awaited first!");
16449 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
16450 return nativeResponseValue;
16452 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
16454 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
16455 if(!isWasmInitialized) {
16456 throw new Error("initializeWasm() must be awaited first!");
16458 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
16459 return nativeResponseValue;
16461 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
16463 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
16464 if(!isWasmInitialized) {
16465 throw new Error("initializeWasm() must be awaited first!");
16467 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
16468 // debug statements here
16470 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
16472 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16473 if(!isWasmInitialized) {
16474 throw new Error("initializeWasm() must be awaited first!");
16476 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
16477 return nativeResponseValue;
16479 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
16481 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
16482 if(!isWasmInitialized) {
16483 throw new Error("initializeWasm() must be awaited first!");
16485 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
16486 return nativeResponseValue;
16488 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
16490 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16491 if(!isWasmInitialized) {
16492 throw new Error("initializeWasm() must be awaited first!");
16494 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
16495 return nativeResponseValue;
16497 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16499 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16500 if(!isWasmInitialized) {
16501 throw new Error("initializeWasm() must be awaited first!");
16503 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
16504 return nativeResponseValue;
16506 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
16508 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16509 if(!isWasmInitialized) {
16510 throw new Error("initializeWasm() must be awaited first!");
16512 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
16513 return nativeResponseValue;
16515 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
16517 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
16518 if(!isWasmInitialized) {
16519 throw new Error("initializeWasm() must be awaited first!");
16521 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
16522 // debug statements here
16524 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16526 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16527 if(!isWasmInitialized) {
16528 throw new Error("initializeWasm() must be awaited first!");
16530 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
16531 return nativeResponseValue;
16533 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16535 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16536 if(!isWasmInitialized) {
16537 throw new Error("initializeWasm() must be awaited first!");
16539 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
16540 return nativeResponseValue;
16542 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
16544 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16545 if(!isWasmInitialized) {
16546 throw new Error("initializeWasm() must be awaited first!");
16548 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
16549 return nativeResponseValue;
16551 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16553 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16554 if(!isWasmInitialized) {
16555 throw new Error("initializeWasm() must be awaited first!");
16557 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
16558 return nativeResponseValue;
16560 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
16562 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16563 if(!isWasmInitialized) {
16564 throw new Error("initializeWasm() must be awaited first!");
16566 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
16567 return nativeResponseValue;
16569 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
16571 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
16572 if(!isWasmInitialized) {
16573 throw new Error("initializeWasm() must be awaited first!");
16575 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
16576 // debug statements here
16578 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16580 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16581 if(!isWasmInitialized) {
16582 throw new Error("initializeWasm() must be awaited first!");
16584 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
16585 return nativeResponseValue;
16587 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16589 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16590 if(!isWasmInitialized) {
16591 throw new Error("initializeWasm() must be awaited first!");
16593 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
16594 return nativeResponseValue;
16596 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
16598 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
16599 if(!isWasmInitialized) {
16600 throw new Error("initializeWasm() must be awaited first!");
16602 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
16603 return nativeResponseValue;
16605 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16607 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
16608 if(!isWasmInitialized) {
16609 throw new Error("initializeWasm() must be awaited first!");
16611 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
16612 return nativeResponseValue;
16614 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
16616 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16617 if(!isWasmInitialized) {
16618 throw new Error("initializeWasm() must be awaited first!");
16620 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
16621 return nativeResponseValue;
16623 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
16625 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
16626 if(!isWasmInitialized) {
16627 throw new Error("initializeWasm() must be awaited first!");
16629 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
16630 // debug statements here
16632 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
16634 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16635 if(!isWasmInitialized) {
16636 throw new Error("initializeWasm() must be awaited first!");
16638 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
16639 return nativeResponseValue;
16641 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
16643 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16644 if(!isWasmInitialized) {
16645 throw new Error("initializeWasm() must be awaited first!");
16647 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
16648 return nativeResponseValue;
16650 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
16652 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
16653 if(!isWasmInitialized) {
16654 throw new Error("initializeWasm() must be awaited first!");
16656 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
16657 return nativeResponseValue;
16659 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16661 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
16662 if(!isWasmInitialized) {
16663 throw new Error("initializeWasm() must be awaited first!");
16665 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
16666 return nativeResponseValue;
16668 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
16670 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16671 if(!isWasmInitialized) {
16672 throw new Error("initializeWasm() must be awaited first!");
16674 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
16675 return nativeResponseValue;
16677 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
16679 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
16680 if(!isWasmInitialized) {
16681 throw new Error("initializeWasm() must be awaited first!");
16683 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
16684 // debug statements here
16686 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
16688 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16689 if(!isWasmInitialized) {
16690 throw new Error("initializeWasm() must be awaited first!");
16692 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
16693 return nativeResponseValue;
16695 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
16697 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16698 if(!isWasmInitialized) {
16699 throw new Error("initializeWasm() must be awaited first!");
16701 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
16702 return nativeResponseValue;
16704 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
16706 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
16707 if(!isWasmInitialized) {
16708 throw new Error("initializeWasm() must be awaited first!");
16710 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
16711 return nativeResponseValue;
16713 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
16715 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
16716 if(!isWasmInitialized) {
16717 throw new Error("initializeWasm() must be awaited first!");
16719 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
16720 return nativeResponseValue;
16722 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
16724 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16725 if(!isWasmInitialized) {
16726 throw new Error("initializeWasm() must be awaited first!");
16728 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
16729 return nativeResponseValue;
16731 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
16733 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
16734 if(!isWasmInitialized) {
16735 throw new Error("initializeWasm() must be awaited first!");
16737 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
16738 // debug statements here
16740 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
16742 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16743 if(!isWasmInitialized) {
16744 throw new Error("initializeWasm() must be awaited first!");
16746 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
16747 return nativeResponseValue;
16749 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
16751 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
16752 if(!isWasmInitialized) {
16753 throw new Error("initializeWasm() must be awaited first!");
16755 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
16756 return nativeResponseValue;
16758 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
16760 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
16761 if(!isWasmInitialized) {
16762 throw new Error("initializeWasm() must be awaited first!");
16764 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
16765 return nativeResponseValue;
16767 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
16769 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
16770 if(!isWasmInitialized) {
16771 throw new Error("initializeWasm() must be awaited first!");
16773 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
16774 return nativeResponseValue;
16776 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
16778 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
16779 if(!isWasmInitialized) {
16780 throw new Error("initializeWasm() must be awaited first!");
16782 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
16783 return nativeResponseValue;
16785 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
16787 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
16788 if(!isWasmInitialized) {
16789 throw new Error("initializeWasm() must be awaited first!");
16791 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
16792 // debug statements here
16794 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
16796 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16797 if(!isWasmInitialized) {
16798 throw new Error("initializeWasm() must be awaited first!");
16800 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
16801 return nativeResponseValue;
16803 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
16805 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
16806 if(!isWasmInitialized) {
16807 throw new Error("initializeWasm() must be awaited first!");
16809 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
16810 return nativeResponseValue;
16812 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
16814 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16815 if(!isWasmInitialized) {
16816 throw new Error("initializeWasm() must be awaited first!");
16818 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
16819 return nativeResponseValue;
16821 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16823 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16824 if(!isWasmInitialized) {
16825 throw new Error("initializeWasm() must be awaited first!");
16827 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
16828 return nativeResponseValue;
16830 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
16832 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16833 if(!isWasmInitialized) {
16834 throw new Error("initializeWasm() must be awaited first!");
16836 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
16837 return nativeResponseValue;
16839 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
16841 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16842 if(!isWasmInitialized) {
16843 throw new Error("initializeWasm() must be awaited first!");
16845 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
16846 // debug statements here
16848 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16850 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16851 if(!isWasmInitialized) {
16852 throw new Error("initializeWasm() must be awaited first!");
16854 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16855 return nativeResponseValue;
16857 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16859 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16860 if(!isWasmInitialized) {
16861 throw new Error("initializeWasm() must be awaited first!");
16863 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
16864 return nativeResponseValue;
16866 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
16868 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
16869 if(!isWasmInitialized) {
16870 throw new Error("initializeWasm() must be awaited first!");
16872 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
16873 return nativeResponseValue;
16875 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
16877 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
16878 if(!isWasmInitialized) {
16879 throw new Error("initializeWasm() must be awaited first!");
16881 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
16882 return nativeResponseValue;
16884 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
16886 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
16887 if(!isWasmInitialized) {
16888 throw new Error("initializeWasm() must be awaited first!");
16890 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
16891 return nativeResponseValue;
16893 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
16895 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
16896 if(!isWasmInitialized) {
16897 throw new Error("initializeWasm() must be awaited first!");
16899 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
16900 // debug statements here
16902 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
16904 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16905 if(!isWasmInitialized) {
16906 throw new Error("initializeWasm() must be awaited first!");
16908 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
16909 return nativeResponseValue;
16911 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
16913 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
16914 if(!isWasmInitialized) {
16915 throw new Error("initializeWasm() must be awaited first!");
16917 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
16918 return nativeResponseValue;
16920 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
16922 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
16923 if(!isWasmInitialized) {
16924 throw new Error("initializeWasm() must be awaited first!");
16926 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
16927 return nativeResponseValue;
16929 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
16931 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
16932 if(!isWasmInitialized) {
16933 throw new Error("initializeWasm() must be awaited first!");
16935 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
16936 return nativeResponseValue;
16938 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
16940 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
16941 if(!isWasmInitialized) {
16942 throw new Error("initializeWasm() must be awaited first!");
16944 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
16945 return nativeResponseValue;
16947 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
16949 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
16950 if(!isWasmInitialized) {
16951 throw new Error("initializeWasm() must be awaited first!");
16953 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
16954 // debug statements here
16956 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
16958 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16959 if(!isWasmInitialized) {
16960 throw new Error("initializeWasm() must be awaited first!");
16962 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
16963 return nativeResponseValue;
16965 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
16967 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
16968 if(!isWasmInitialized) {
16969 throw new Error("initializeWasm() must be awaited first!");
16971 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
16972 return nativeResponseValue;
16974 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
16976 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
16977 if(!isWasmInitialized) {
16978 throw new Error("initializeWasm() must be awaited first!");
16980 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
16981 return nativeResponseValue;
16983 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
16985 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
16986 if(!isWasmInitialized) {
16987 throw new Error("initializeWasm() must be awaited first!");
16989 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
16990 return nativeResponseValue;
16992 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
16994 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
16995 if(!isWasmInitialized) {
16996 throw new Error("initializeWasm() must be awaited first!");
16998 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
16999 return nativeResponseValue;
17001 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
17003 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
17004 if(!isWasmInitialized) {
17005 throw new Error("initializeWasm() must be awaited first!");
17007 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
17008 // debug statements here
17010 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
17012 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17013 if(!isWasmInitialized) {
17014 throw new Error("initializeWasm() must be awaited first!");
17016 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
17017 return nativeResponseValue;
17019 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
17021 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
17022 if(!isWasmInitialized) {
17023 throw new Error("initializeWasm() must be awaited first!");
17025 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
17026 return nativeResponseValue;
17028 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
17030 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
17031 if(!isWasmInitialized) {
17032 throw new Error("initializeWasm() must be awaited first!");
17034 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
17035 return nativeResponseValue;
17037 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
17039 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
17040 if(!isWasmInitialized) {
17041 throw new Error("initializeWasm() must be awaited first!");
17043 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
17044 return nativeResponseValue;
17046 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
17048 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
17049 if(!isWasmInitialized) {
17050 throw new Error("initializeWasm() must be awaited first!");
17052 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
17053 return nativeResponseValue;
17055 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
17057 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
17058 if(!isWasmInitialized) {
17059 throw new Error("initializeWasm() must be awaited first!");
17061 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
17062 // debug statements here
17064 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
17066 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17067 if(!isWasmInitialized) {
17068 throw new Error("initializeWasm() must be awaited first!");
17070 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
17071 return nativeResponseValue;
17073 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
17075 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
17076 if(!isWasmInitialized) {
17077 throw new Error("initializeWasm() must be awaited first!");
17079 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
17080 return nativeResponseValue;
17082 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
17084 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
17085 if(!isWasmInitialized) {
17086 throw new Error("initializeWasm() must be awaited first!");
17088 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
17089 return nativeResponseValue;
17091 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
17093 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
17094 if(!isWasmInitialized) {
17095 throw new Error("initializeWasm() must be awaited first!");
17097 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
17098 return nativeResponseValue;
17100 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
17102 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
17103 if(!isWasmInitialized) {
17104 throw new Error("initializeWasm() must be awaited first!");
17106 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
17107 return nativeResponseValue;
17109 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
17111 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
17112 if(!isWasmInitialized) {
17113 throw new Error("initializeWasm() must be awaited first!");
17115 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
17116 // debug statements here
17118 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
17120 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17121 if(!isWasmInitialized) {
17122 throw new Error("initializeWasm() must be awaited first!");
17124 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
17125 return nativeResponseValue;
17127 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
17129 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
17130 if(!isWasmInitialized) {
17131 throw new Error("initializeWasm() must be awaited first!");
17133 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
17134 return nativeResponseValue;
17136 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
17138 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
17139 if(!isWasmInitialized) {
17140 throw new Error("initializeWasm() must be awaited first!");
17142 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
17143 return nativeResponseValue;
17145 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
17147 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
17148 if(!isWasmInitialized) {
17149 throw new Error("initializeWasm() must be awaited first!");
17151 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
17152 return nativeResponseValue;
17154 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
17156 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
17157 if(!isWasmInitialized) {
17158 throw new Error("initializeWasm() must be awaited first!");
17160 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
17161 return nativeResponseValue;
17163 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
17165 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
17166 if(!isWasmInitialized) {
17167 throw new Error("initializeWasm() must be awaited first!");
17169 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
17170 // debug statements here
17172 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
17174 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17175 if(!isWasmInitialized) {
17176 throw new Error("initializeWasm() must be awaited first!");
17178 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
17179 return nativeResponseValue;
17181 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
17183 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
17184 if(!isWasmInitialized) {
17185 throw new Error("initializeWasm() must be awaited first!");
17187 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
17188 return nativeResponseValue;
17190 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
17192 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
17193 if(!isWasmInitialized) {
17194 throw new Error("initializeWasm() must be awaited first!");
17196 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
17197 return nativeResponseValue;
17199 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
17201 export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
17202 if(!isWasmInitialized) {
17203 throw new Error("initializeWasm() must be awaited first!");
17205 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
17206 return nativeResponseValue;
17208 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
17210 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
17211 if(!isWasmInitialized) {
17212 throw new Error("initializeWasm() must be awaited first!");
17214 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
17215 return nativeResponseValue;
17217 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
17219 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
17220 if(!isWasmInitialized) {
17221 throw new Error("initializeWasm() must be awaited first!");
17223 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
17224 // debug statements here
17226 // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
17228 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
17229 if(!isWasmInitialized) {
17230 throw new Error("initializeWasm() must be awaited first!");
17232 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
17233 return nativeResponseValue;
17235 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
17237 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
17238 if(!isWasmInitialized) {
17239 throw new Error("initializeWasm() must be awaited first!");
17241 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
17242 return nativeResponseValue;
17244 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
17246 export function COption_FilterZ_some(o: bigint): bigint {
17247 if(!isWasmInitialized) {
17248 throw new Error("initializeWasm() must be awaited first!");
17250 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
17251 return nativeResponseValue;
17253 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
17255 export function COption_FilterZ_none(): bigint {
17256 if(!isWasmInitialized) {
17257 throw new Error("initializeWasm() must be awaited first!");
17259 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
17260 return nativeResponseValue;
17262 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
17264 export function COption_FilterZ_free(_res: bigint): void {
17265 if(!isWasmInitialized) {
17266 throw new Error("initializeWasm() must be awaited first!");
17268 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
17269 // debug statements here
17271 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
17273 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
17274 if(!isWasmInitialized) {
17275 throw new Error("initializeWasm() must be awaited first!");
17277 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
17278 return nativeResponseValue;
17280 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
17282 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
17283 if(!isWasmInitialized) {
17284 throw new Error("initializeWasm() must be awaited first!");
17286 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
17287 return nativeResponseValue;
17289 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
17291 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
17292 if(!isWasmInitialized) {
17293 throw new Error("initializeWasm() must be awaited first!");
17295 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
17296 return nativeResponseValue;
17298 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
17300 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
17301 if(!isWasmInitialized) {
17302 throw new Error("initializeWasm() must be awaited first!");
17304 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
17305 // debug statements here
17307 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
17309 export function CVec_OutPointZ_free(_res: number): void {
17310 if(!isWasmInitialized) {
17311 throw new Error("initializeWasm() must be awaited first!");
17313 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
17314 // debug statements here
17316 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
17318 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
17319 if(!isWasmInitialized) {
17320 throw new Error("initializeWasm() must be awaited first!");
17322 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
17323 // debug statements here
17325 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
17327 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
17328 if(!isWasmInitialized) {
17329 throw new Error("initializeWasm() must be awaited first!");
17331 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
17332 return nativeResponseValue;
17334 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
17336 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
17337 if(!isWasmInitialized) {
17338 throw new Error("initializeWasm() must be awaited first!");
17340 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
17341 return nativeResponseValue;
17343 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
17345 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
17346 if(!isWasmInitialized) {
17347 throw new Error("initializeWasm() must be awaited first!");
17349 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
17350 return nativeResponseValue;
17352 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
17354 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
17355 if(!isWasmInitialized) {
17356 throw new Error("initializeWasm() must be awaited first!");
17358 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
17359 // debug statements here
17361 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
17363 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
17364 if(!isWasmInitialized) {
17365 throw new Error("initializeWasm() must be awaited first!");
17367 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
17368 // debug statements here
17370 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
17372 export function PaymentPurpose_free(this_ptr: bigint): void {
17373 if(!isWasmInitialized) {
17374 throw new Error("initializeWasm() must be awaited first!");
17376 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
17377 // debug statements here
17379 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
17381 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
17382 if(!isWasmInitialized) {
17383 throw new Error("initializeWasm() must be awaited first!");
17385 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
17386 return nativeResponseValue;
17388 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
17390 export function PaymentPurpose_clone(orig: bigint): bigint {
17391 if(!isWasmInitialized) {
17392 throw new Error("initializeWasm() must be awaited first!");
17394 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
17395 return nativeResponseValue;
17397 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
17399 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
17400 if(!isWasmInitialized) {
17401 throw new Error("initializeWasm() must be awaited first!");
17403 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
17404 return nativeResponseValue;
17406 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
17408 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
17409 if(!isWasmInitialized) {
17410 throw new Error("initializeWasm() must be awaited first!");
17412 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
17413 return nativeResponseValue;
17415 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
17417 export function PaymentPurpose_write(obj: bigint): number {
17418 if(!isWasmInitialized) {
17419 throw new Error("initializeWasm() must be awaited first!");
17421 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
17422 return nativeResponseValue;
17424 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
17426 export function PaymentPurpose_read(ser: number): bigint {
17427 if(!isWasmInitialized) {
17428 throw new Error("initializeWasm() must be awaited first!");
17430 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
17431 return nativeResponseValue;
17433 // void ClosureReason_free(struct LDKClosureReason this_ptr);
17435 export function ClosureReason_free(this_ptr: bigint): void {
17436 if(!isWasmInitialized) {
17437 throw new Error("initializeWasm() must be awaited first!");
17439 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
17440 // debug statements here
17442 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
17444 export function ClosureReason_clone_ptr(arg: bigint): bigint {
17445 if(!isWasmInitialized) {
17446 throw new Error("initializeWasm() must be awaited first!");
17448 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
17449 return nativeResponseValue;
17451 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
17453 export function ClosureReason_clone(orig: bigint): bigint {
17454 if(!isWasmInitialized) {
17455 throw new Error("initializeWasm() must be awaited first!");
17457 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
17458 return nativeResponseValue;
17460 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
17462 export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
17463 if(!isWasmInitialized) {
17464 throw new Error("initializeWasm() must be awaited first!");
17466 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
17467 return nativeResponseValue;
17469 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
17471 export function ClosureReason_holder_force_closed(): bigint {
17472 if(!isWasmInitialized) {
17473 throw new Error("initializeWasm() must be awaited first!");
17475 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
17476 return nativeResponseValue;
17478 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
17480 export function ClosureReason_cooperative_closure(): bigint {
17481 if(!isWasmInitialized) {
17482 throw new Error("initializeWasm() must be awaited first!");
17484 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
17485 return nativeResponseValue;
17487 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
17489 export function ClosureReason_commitment_tx_confirmed(): bigint {
17490 if(!isWasmInitialized) {
17491 throw new Error("initializeWasm() must be awaited first!");
17493 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
17494 return nativeResponseValue;
17496 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
17498 export function ClosureReason_funding_timed_out(): bigint {
17499 if(!isWasmInitialized) {
17500 throw new Error("initializeWasm() must be awaited first!");
17502 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
17503 return nativeResponseValue;
17505 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
17507 export function ClosureReason_processing_error(err: number): bigint {
17508 if(!isWasmInitialized) {
17509 throw new Error("initializeWasm() must be awaited first!");
17511 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
17512 return nativeResponseValue;
17514 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
17516 export function ClosureReason_disconnected_peer(): bigint {
17517 if(!isWasmInitialized) {
17518 throw new Error("initializeWasm() must be awaited first!");
17520 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
17521 return nativeResponseValue;
17523 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
17525 export function ClosureReason_outdated_channel_manager(): bigint {
17526 if(!isWasmInitialized) {
17527 throw new Error("initializeWasm() must be awaited first!");
17529 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
17530 return nativeResponseValue;
17532 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
17534 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
17535 if(!isWasmInitialized) {
17536 throw new Error("initializeWasm() must be awaited first!");
17538 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
17539 return nativeResponseValue;
17541 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
17543 export function ClosureReason_write(obj: bigint): number {
17544 if(!isWasmInitialized) {
17545 throw new Error("initializeWasm() must be awaited first!");
17547 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
17548 return nativeResponseValue;
17550 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
17552 export function ClosureReason_read(ser: number): bigint {
17553 if(!isWasmInitialized) {
17554 throw new Error("initializeWasm() must be awaited first!");
17556 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
17557 return nativeResponseValue;
17559 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
17561 export function HTLCDestination_free(this_ptr: bigint): void {
17562 if(!isWasmInitialized) {
17563 throw new Error("initializeWasm() must be awaited first!");
17565 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
17566 // debug statements here
17568 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
17570 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
17571 if(!isWasmInitialized) {
17572 throw new Error("initializeWasm() must be awaited first!");
17574 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
17575 return nativeResponseValue;
17577 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
17579 export function HTLCDestination_clone(orig: bigint): bigint {
17580 if(!isWasmInitialized) {
17581 throw new Error("initializeWasm() must be awaited first!");
17583 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
17584 return nativeResponseValue;
17586 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
17588 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
17589 if(!isWasmInitialized) {
17590 throw new Error("initializeWasm() must be awaited first!");
17592 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
17593 return nativeResponseValue;
17595 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
17597 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
17598 if(!isWasmInitialized) {
17599 throw new Error("initializeWasm() must be awaited first!");
17601 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
17602 return nativeResponseValue;
17604 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
17606 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
17607 if(!isWasmInitialized) {
17608 throw new Error("initializeWasm() must be awaited first!");
17610 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
17611 return nativeResponseValue;
17613 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
17615 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
17616 if(!isWasmInitialized) {
17617 throw new Error("initializeWasm() must be awaited first!");
17619 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
17620 return nativeResponseValue;
17622 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
17624 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
17625 if(!isWasmInitialized) {
17626 throw new Error("initializeWasm() must be awaited first!");
17628 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
17629 return nativeResponseValue;
17631 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
17633 export function HTLCDestination_write(obj: bigint): number {
17634 if(!isWasmInitialized) {
17635 throw new Error("initializeWasm() must be awaited first!");
17637 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
17638 return nativeResponseValue;
17640 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
17642 export function HTLCDestination_read(ser: number): bigint {
17643 if(!isWasmInitialized) {
17644 throw new Error("initializeWasm() must be awaited first!");
17646 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
17647 return nativeResponseValue;
17649 // void Event_free(struct LDKEvent this_ptr);
17651 export function Event_free(this_ptr: bigint): void {
17652 if(!isWasmInitialized) {
17653 throw new Error("initializeWasm() must be awaited first!");
17655 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
17656 // debug statements here
17658 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
17660 export function Event_clone_ptr(arg: bigint): bigint {
17661 if(!isWasmInitialized) {
17662 throw new Error("initializeWasm() must be awaited first!");
17664 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
17665 return nativeResponseValue;
17667 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
17669 export function Event_clone(orig: bigint): bigint {
17670 if(!isWasmInitialized) {
17671 throw new Error("initializeWasm() must be awaited first!");
17673 const nativeResponseValue = wasm.TS_Event_clone(orig);
17674 return nativeResponseValue;
17676 // 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, struct LDKU128 user_channel_id);
17678 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
17679 if(!isWasmInitialized) {
17680 throw new Error("initializeWasm() must be awaited first!");
17682 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
17683 return nativeResponseValue;
17685 // struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKThirtyTwoBytes via_channel_id, struct LDKCOption_u128Z via_user_channel_id);
17687 export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint, via_channel_id: number, via_user_channel_id: bigint): bigint {
17688 if(!isWasmInitialized) {
17689 throw new Error("initializeWasm() must be awaited first!");
17691 const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, amount_msat, purpose, via_channel_id, via_user_channel_id);
17692 return nativeResponseValue;
17694 // struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
17696 export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
17697 if(!isWasmInitialized) {
17698 throw new Error("initializeWasm() must be awaited first!");
17700 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose);
17701 return nativeResponseValue;
17703 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
17705 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
17706 if(!isWasmInitialized) {
17707 throw new Error("initializeWasm() must be awaited first!");
17709 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
17710 return nativeResponseValue;
17712 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
17714 export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
17715 if(!isWasmInitialized) {
17716 throw new Error("initializeWasm() must be awaited first!");
17718 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
17719 return nativeResponseValue;
17721 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
17723 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
17724 if(!isWasmInitialized) {
17725 throw new Error("initializeWasm() must be awaited first!");
17727 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
17728 return nativeResponseValue;
17730 // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKCOption_NetworkUpdateZ network_update, bool all_paths_failed, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
17732 export function Event_payment_path_failed(payment_id: number, payment_hash: number, payment_failed_permanently: boolean, network_update: bigint, all_paths_failed: boolean, path: number, short_channel_id: bigint, retry: bigint): bigint {
17733 if(!isWasmInitialized) {
17734 throw new Error("initializeWasm() must be awaited first!");
17736 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, network_update, all_paths_failed, path, short_channel_id, retry);
17737 return nativeResponseValue;
17739 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
17741 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
17742 if(!isWasmInitialized) {
17743 throw new Error("initializeWasm() must be awaited first!");
17745 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
17746 return nativeResponseValue;
17748 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
17750 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
17751 if(!isWasmInitialized) {
17752 throw new Error("initializeWasm() must be awaited first!");
17754 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
17755 return nativeResponseValue;
17757 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
17759 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
17760 if(!isWasmInitialized) {
17761 throw new Error("initializeWasm() must be awaited first!");
17763 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
17764 return nativeResponseValue;
17766 // struct LDKEvent Event_htlcintercepted(struct LDKThirtyTwoBytes intercept_id, uint64_t requested_next_hop_scid, struct LDKThirtyTwoBytes payment_hash, uint64_t inbound_amount_msat, uint64_t expected_outbound_amount_msat);
17768 export function Event_htlcintercepted(intercept_id: number, requested_next_hop_scid: bigint, payment_hash: number, inbound_amount_msat: bigint, expected_outbound_amount_msat: bigint): bigint {
17769 if(!isWasmInitialized) {
17770 throw new Error("initializeWasm() must be awaited first!");
17772 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
17773 return nativeResponseValue;
17775 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
17777 export function Event_spendable_outputs(outputs: number): bigint {
17778 if(!isWasmInitialized) {
17779 throw new Error("initializeWasm() must be awaited first!");
17781 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
17782 return nativeResponseValue;
17784 // 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);
17786 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
17787 if(!isWasmInitialized) {
17788 throw new Error("initializeWasm() must be awaited first!");
17790 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
17791 return nativeResponseValue;
17793 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
17795 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
17796 if(!isWasmInitialized) {
17797 throw new Error("initializeWasm() must be awaited first!");
17799 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
17800 return nativeResponseValue;
17802 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason);
17804 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint): bigint {
17805 if(!isWasmInitialized) {
17806 throw new Error("initializeWasm() must be awaited first!");
17808 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
17809 return nativeResponseValue;
17811 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
17813 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
17814 if(!isWasmInitialized) {
17815 throw new Error("initializeWasm() must be awaited first!");
17817 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
17818 return nativeResponseValue;
17820 // 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);
17822 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
17823 if(!isWasmInitialized) {
17824 throw new Error("initializeWasm() must be awaited first!");
17826 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
17827 return nativeResponseValue;
17829 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
17831 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
17832 if(!isWasmInitialized) {
17833 throw new Error("initializeWasm() must be awaited first!");
17835 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
17836 return nativeResponseValue;
17838 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
17840 export function Event_write(obj: bigint): number {
17841 if(!isWasmInitialized) {
17842 throw new Error("initializeWasm() must be awaited first!");
17844 const nativeResponseValue = wasm.TS_Event_write(obj);
17845 return nativeResponseValue;
17847 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
17849 export function Event_read(ser: number): bigint {
17850 if(!isWasmInitialized) {
17851 throw new Error("initializeWasm() must be awaited first!");
17853 const nativeResponseValue = wasm.TS_Event_read(ser);
17854 return nativeResponseValue;
17856 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
17858 export function MessageSendEvent_free(this_ptr: bigint): void {
17859 if(!isWasmInitialized) {
17860 throw new Error("initializeWasm() must be awaited first!");
17862 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
17863 // debug statements here
17865 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
17867 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
17868 if(!isWasmInitialized) {
17869 throw new Error("initializeWasm() must be awaited first!");
17871 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
17872 return nativeResponseValue;
17874 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
17876 export function MessageSendEvent_clone(orig: bigint): bigint {
17877 if(!isWasmInitialized) {
17878 throw new Error("initializeWasm() must be awaited first!");
17880 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
17881 return nativeResponseValue;
17883 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
17885 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
17886 if(!isWasmInitialized) {
17887 throw new Error("initializeWasm() must be awaited first!");
17889 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
17890 return nativeResponseValue;
17892 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
17894 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
17895 if(!isWasmInitialized) {
17896 throw new Error("initializeWasm() must be awaited first!");
17898 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
17899 return nativeResponseValue;
17901 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
17903 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
17904 if(!isWasmInitialized) {
17905 throw new Error("initializeWasm() must be awaited first!");
17907 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
17908 return nativeResponseValue;
17910 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
17912 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
17913 if(!isWasmInitialized) {
17914 throw new Error("initializeWasm() must be awaited first!");
17916 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
17917 return nativeResponseValue;
17919 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
17921 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
17922 if(!isWasmInitialized) {
17923 throw new Error("initializeWasm() must be awaited first!");
17925 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
17926 return nativeResponseValue;
17928 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
17930 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
17931 if(!isWasmInitialized) {
17932 throw new Error("initializeWasm() must be awaited first!");
17934 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
17935 return nativeResponseValue;
17937 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
17939 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
17940 if(!isWasmInitialized) {
17941 throw new Error("initializeWasm() must be awaited first!");
17943 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
17944 return nativeResponseValue;
17946 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
17948 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
17949 if(!isWasmInitialized) {
17950 throw new Error("initializeWasm() must be awaited first!");
17952 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
17953 return nativeResponseValue;
17955 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
17957 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
17958 if(!isWasmInitialized) {
17959 throw new Error("initializeWasm() must be awaited first!");
17961 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
17962 return nativeResponseValue;
17964 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
17966 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
17967 if(!isWasmInitialized) {
17968 throw new Error("initializeWasm() must be awaited first!");
17970 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
17971 return nativeResponseValue;
17973 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
17975 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
17976 if(!isWasmInitialized) {
17977 throw new Error("initializeWasm() must be awaited first!");
17979 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
17980 return nativeResponseValue;
17982 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17984 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
17985 if(!isWasmInitialized) {
17986 throw new Error("initializeWasm() must be awaited first!");
17988 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
17989 return nativeResponseValue;
17991 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
17993 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
17994 if(!isWasmInitialized) {
17995 throw new Error("initializeWasm() must be awaited first!");
17997 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
17998 return nativeResponseValue;
18000 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
18002 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
18003 if(!isWasmInitialized) {
18004 throw new Error("initializeWasm() must be awaited first!");
18006 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
18007 return nativeResponseValue;
18009 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
18011 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
18012 if(!isWasmInitialized) {
18013 throw new Error("initializeWasm() must be awaited first!");
18015 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
18016 return nativeResponseValue;
18018 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
18020 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
18021 if(!isWasmInitialized) {
18022 throw new Error("initializeWasm() must be awaited first!");
18024 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
18025 return nativeResponseValue;
18027 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
18029 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
18030 if(!isWasmInitialized) {
18031 throw new Error("initializeWasm() must be awaited first!");
18033 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
18034 return nativeResponseValue;
18036 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
18038 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
18039 if(!isWasmInitialized) {
18040 throw new Error("initializeWasm() must be awaited first!");
18042 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
18043 return nativeResponseValue;
18045 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
18047 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
18048 if(!isWasmInitialized) {
18049 throw new Error("initializeWasm() must be awaited first!");
18051 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
18052 return nativeResponseValue;
18054 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
18056 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
18057 if(!isWasmInitialized) {
18058 throw new Error("initializeWasm() must be awaited first!");
18060 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
18061 return nativeResponseValue;
18063 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
18065 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
18066 if(!isWasmInitialized) {
18067 throw new Error("initializeWasm() must be awaited first!");
18069 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
18070 // debug statements here
18072 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
18074 export function OnionMessageProvider_free(this_ptr: bigint): void {
18075 if(!isWasmInitialized) {
18076 throw new Error("initializeWasm() must be awaited first!");
18078 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
18079 // debug statements here
18081 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
18083 export function EventsProvider_free(this_ptr: bigint): void {
18084 if(!isWasmInitialized) {
18085 throw new Error("initializeWasm() must be awaited first!");
18087 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
18088 // debug statements here
18090 // void EventHandler_free(struct LDKEventHandler this_ptr);
18092 export function EventHandler_free(this_ptr: bigint): void {
18093 if(!isWasmInitialized) {
18094 throw new Error("initializeWasm() must be awaited first!");
18096 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
18097 // debug statements here
18099 // void APIError_free(struct LDKAPIError this_ptr);
18101 export function APIError_free(this_ptr: bigint): void {
18102 if(!isWasmInitialized) {
18103 throw new Error("initializeWasm() must be awaited first!");
18105 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
18106 // debug statements here
18108 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
18110 export function APIError_clone_ptr(arg: bigint): bigint {
18111 if(!isWasmInitialized) {
18112 throw new Error("initializeWasm() must be awaited first!");
18114 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
18115 return nativeResponseValue;
18117 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
18119 export function APIError_clone(orig: bigint): bigint {
18120 if(!isWasmInitialized) {
18121 throw new Error("initializeWasm() must be awaited first!");
18123 const nativeResponseValue = wasm.TS_APIError_clone(orig);
18124 return nativeResponseValue;
18126 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
18128 export function APIError_apimisuse_error(err: number): bigint {
18129 if(!isWasmInitialized) {
18130 throw new Error("initializeWasm() must be awaited first!");
18132 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
18133 return nativeResponseValue;
18135 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
18137 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
18138 if(!isWasmInitialized) {
18139 throw new Error("initializeWasm() must be awaited first!");
18141 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
18142 return nativeResponseValue;
18144 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
18146 export function APIError_invalid_route(err: number): bigint {
18147 if(!isWasmInitialized) {
18148 throw new Error("initializeWasm() must be awaited first!");
18150 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
18151 return nativeResponseValue;
18153 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
18155 export function APIError_channel_unavailable(err: number): bigint {
18156 if(!isWasmInitialized) {
18157 throw new Error("initializeWasm() must be awaited first!");
18159 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
18160 return nativeResponseValue;
18162 // struct LDKAPIError APIError_monitor_update_in_progress(void);
18164 export function APIError_monitor_update_in_progress(): bigint {
18165 if(!isWasmInitialized) {
18166 throw new Error("initializeWasm() must be awaited first!");
18168 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
18169 return nativeResponseValue;
18171 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
18173 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
18174 if(!isWasmInitialized) {
18175 throw new Error("initializeWasm() must be awaited first!");
18177 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
18178 return nativeResponseValue;
18180 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
18182 export function APIError_eq(a: bigint, b: bigint): boolean {
18183 if(!isWasmInitialized) {
18184 throw new Error("initializeWasm() must be awaited first!");
18186 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
18187 return nativeResponseValue;
18189 // void BigSize_free(struct LDKBigSize this_obj);
18191 export function BigSize_free(this_obj: bigint): void {
18192 if(!isWasmInitialized) {
18193 throw new Error("initializeWasm() must be awaited first!");
18195 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
18196 // debug statements here
18198 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
18200 export function BigSize_get_a(this_ptr: bigint): bigint {
18201 if(!isWasmInitialized) {
18202 throw new Error("initializeWasm() must be awaited first!");
18204 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
18205 return nativeResponseValue;
18207 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
18209 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
18210 if(!isWasmInitialized) {
18211 throw new Error("initializeWasm() must be awaited first!");
18213 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
18214 // debug statements here
18216 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
18218 export function BigSize_new(a_arg: bigint): bigint {
18219 if(!isWasmInitialized) {
18220 throw new Error("initializeWasm() must be awaited first!");
18222 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
18223 return nativeResponseValue;
18225 // void Hostname_free(struct LDKHostname this_obj);
18227 export function Hostname_free(this_obj: bigint): void {
18228 if(!isWasmInitialized) {
18229 throw new Error("initializeWasm() must be awaited first!");
18231 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
18232 // debug statements here
18234 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
18236 export function Hostname_clone_ptr(arg: bigint): bigint {
18237 if(!isWasmInitialized) {
18238 throw new Error("initializeWasm() must be awaited first!");
18240 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
18241 return nativeResponseValue;
18243 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
18245 export function Hostname_clone(orig: bigint): bigint {
18246 if(!isWasmInitialized) {
18247 throw new Error("initializeWasm() must be awaited first!");
18249 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
18250 return nativeResponseValue;
18252 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
18254 export function Hostname_eq(a: bigint, b: bigint): boolean {
18255 if(!isWasmInitialized) {
18256 throw new Error("initializeWasm() must be awaited first!");
18258 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
18259 return nativeResponseValue;
18261 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
18263 export function Hostname_len(this_arg: bigint): number {
18264 if(!isWasmInitialized) {
18265 throw new Error("initializeWasm() must be awaited first!");
18267 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
18268 return nativeResponseValue;
18270 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
18272 export function sign(msg: number, sk: number): bigint {
18273 if(!isWasmInitialized) {
18274 throw new Error("initializeWasm() must be awaited first!");
18276 const nativeResponseValue = wasm.TS_sign(msg, sk);
18277 return nativeResponseValue;
18279 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
18281 export function recover_pk(msg: number, sig: number): bigint {
18282 if(!isWasmInitialized) {
18283 throw new Error("initializeWasm() must be awaited first!");
18285 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
18286 return nativeResponseValue;
18288 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
18290 export function verify(msg: number, sig: number, pk: number): boolean {
18291 if(!isWasmInitialized) {
18292 throw new Error("initializeWasm() must be awaited first!");
18294 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
18295 return nativeResponseValue;
18297 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
18299 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
18300 if(!isWasmInitialized) {
18301 throw new Error("initializeWasm() must be awaited first!");
18303 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
18304 return nativeResponseValue;
18306 // void Persister_free(struct LDKPersister this_ptr);
18308 export function Persister_free(this_ptr: bigint): void {
18309 if(!isWasmInitialized) {
18310 throw new Error("initializeWasm() must be awaited first!");
18312 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
18313 // debug statements here
18315 // void PrintableString_free(struct LDKPrintableString this_obj);
18317 export function PrintableString_free(this_obj: bigint): void {
18318 if(!isWasmInitialized) {
18319 throw new Error("initializeWasm() must be awaited first!");
18321 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
18322 // debug statements here
18324 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
18326 export function PrintableString_get_a(this_ptr: bigint): number {
18327 if(!isWasmInitialized) {
18328 throw new Error("initializeWasm() must be awaited first!");
18330 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
18331 return nativeResponseValue;
18333 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
18335 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
18336 if(!isWasmInitialized) {
18337 throw new Error("initializeWasm() must be awaited first!");
18339 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
18340 // debug statements here
18342 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
18344 export function PrintableString_new(a_arg: number): bigint {
18345 if(!isWasmInitialized) {
18346 throw new Error("initializeWasm() must be awaited first!");
18348 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
18349 return nativeResponseValue;
18351 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
18353 export function FutureCallback_free(this_ptr: bigint): void {
18354 if(!isWasmInitialized) {
18355 throw new Error("initializeWasm() must be awaited first!");
18357 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
18358 // debug statements here
18360 // void Future_free(struct LDKFuture this_obj);
18362 export function Future_free(this_obj: bigint): void {
18363 if(!isWasmInitialized) {
18364 throw new Error("initializeWasm() must be awaited first!");
18366 const nativeResponseValue = wasm.TS_Future_free(this_obj);
18367 // debug statements here
18369 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
18371 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
18372 if(!isWasmInitialized) {
18373 throw new Error("initializeWasm() must be awaited first!");
18375 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
18376 // debug statements here
18378 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
18380 export function Level_clone(orig: bigint): Level {
18381 if(!isWasmInitialized) {
18382 throw new Error("initializeWasm() must be awaited first!");
18384 const nativeResponseValue = wasm.TS_Level_clone(orig);
18385 return nativeResponseValue;
18387 // enum LDKLevel Level_gossip(void);
18389 export function Level_gossip(): Level {
18390 if(!isWasmInitialized) {
18391 throw new Error("initializeWasm() must be awaited first!");
18393 const nativeResponseValue = wasm.TS_Level_gossip();
18394 return nativeResponseValue;
18396 // enum LDKLevel Level_trace(void);
18398 export function Level_trace(): Level {
18399 if(!isWasmInitialized) {
18400 throw new Error("initializeWasm() must be awaited first!");
18402 const nativeResponseValue = wasm.TS_Level_trace();
18403 return nativeResponseValue;
18405 // enum LDKLevel Level_debug(void);
18407 export function Level_debug(): Level {
18408 if(!isWasmInitialized) {
18409 throw new Error("initializeWasm() must be awaited first!");
18411 const nativeResponseValue = wasm.TS_Level_debug();
18412 return nativeResponseValue;
18414 // enum LDKLevel Level_info(void);
18416 export function Level_info(): Level {
18417 if(!isWasmInitialized) {
18418 throw new Error("initializeWasm() must be awaited first!");
18420 const nativeResponseValue = wasm.TS_Level_info();
18421 return nativeResponseValue;
18423 // enum LDKLevel Level_warn(void);
18425 export function Level_warn(): Level {
18426 if(!isWasmInitialized) {
18427 throw new Error("initializeWasm() must be awaited first!");
18429 const nativeResponseValue = wasm.TS_Level_warn();
18430 return nativeResponseValue;
18432 // enum LDKLevel Level_error(void);
18434 export function Level_error(): Level {
18435 if(!isWasmInitialized) {
18436 throw new Error("initializeWasm() must be awaited first!");
18438 const nativeResponseValue = wasm.TS_Level_error();
18439 return nativeResponseValue;
18441 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
18443 export function Level_eq(a: bigint, b: bigint): boolean {
18444 if(!isWasmInitialized) {
18445 throw new Error("initializeWasm() must be awaited first!");
18447 const nativeResponseValue = wasm.TS_Level_eq(a, b);
18448 return nativeResponseValue;
18450 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
18452 export function Level_hash(o: bigint): bigint {
18453 if(!isWasmInitialized) {
18454 throw new Error("initializeWasm() must be awaited first!");
18456 const nativeResponseValue = wasm.TS_Level_hash(o);
18457 return nativeResponseValue;
18459 // MUST_USE_RES enum LDKLevel Level_max(void);
18461 export function Level_max(): Level {
18462 if(!isWasmInitialized) {
18463 throw new Error("initializeWasm() must be awaited first!");
18465 const nativeResponseValue = wasm.TS_Level_max();
18466 return nativeResponseValue;
18468 // void Record_free(struct LDKRecord this_obj);
18470 export function Record_free(this_obj: bigint): void {
18471 if(!isWasmInitialized) {
18472 throw new Error("initializeWasm() must be awaited first!");
18474 const nativeResponseValue = wasm.TS_Record_free(this_obj);
18475 // debug statements here
18477 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
18479 export function Record_get_level(this_ptr: bigint): Level {
18480 if(!isWasmInitialized) {
18481 throw new Error("initializeWasm() must be awaited first!");
18483 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
18484 return nativeResponseValue;
18486 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
18488 export function Record_set_level(this_ptr: bigint, val: Level): void {
18489 if(!isWasmInitialized) {
18490 throw new Error("initializeWasm() must be awaited first!");
18492 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
18493 // debug statements here
18495 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
18497 export function Record_get_args(this_ptr: bigint): number {
18498 if(!isWasmInitialized) {
18499 throw new Error("initializeWasm() must be awaited first!");
18501 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
18502 return nativeResponseValue;
18504 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
18506 export function Record_set_args(this_ptr: bigint, val: number): void {
18507 if(!isWasmInitialized) {
18508 throw new Error("initializeWasm() must be awaited first!");
18510 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
18511 // debug statements here
18513 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
18515 export function Record_get_module_path(this_ptr: bigint): number {
18516 if(!isWasmInitialized) {
18517 throw new Error("initializeWasm() must be awaited first!");
18519 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
18520 return nativeResponseValue;
18522 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
18524 export function Record_set_module_path(this_ptr: bigint, val: number): void {
18525 if(!isWasmInitialized) {
18526 throw new Error("initializeWasm() must be awaited first!");
18528 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
18529 // debug statements here
18531 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
18533 export function Record_get_file(this_ptr: bigint): number {
18534 if(!isWasmInitialized) {
18535 throw new Error("initializeWasm() must be awaited first!");
18537 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
18538 return nativeResponseValue;
18540 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
18542 export function Record_set_file(this_ptr: bigint, val: number): void {
18543 if(!isWasmInitialized) {
18544 throw new Error("initializeWasm() must be awaited first!");
18546 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
18547 // debug statements here
18549 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
18551 export function Record_get_line(this_ptr: bigint): number {
18552 if(!isWasmInitialized) {
18553 throw new Error("initializeWasm() must be awaited first!");
18555 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
18556 return nativeResponseValue;
18558 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
18560 export function Record_set_line(this_ptr: bigint, val: number): void {
18561 if(!isWasmInitialized) {
18562 throw new Error("initializeWasm() must be awaited first!");
18564 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
18565 // debug statements here
18567 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
18569 export function Record_clone_ptr(arg: bigint): bigint {
18570 if(!isWasmInitialized) {
18571 throw new Error("initializeWasm() must be awaited first!");
18573 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
18574 return nativeResponseValue;
18576 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
18578 export function Record_clone(orig: bigint): bigint {
18579 if(!isWasmInitialized) {
18580 throw new Error("initializeWasm() must be awaited first!");
18582 const nativeResponseValue = wasm.TS_Record_clone(orig);
18583 return nativeResponseValue;
18585 // void Logger_free(struct LDKLogger this_ptr);
18587 export function Logger_free(this_ptr: bigint): void {
18588 if(!isWasmInitialized) {
18589 throw new Error("initializeWasm() must be awaited first!");
18591 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
18592 // debug statements here
18594 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
18596 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
18597 if(!isWasmInitialized) {
18598 throw new Error("initializeWasm() must be awaited first!");
18600 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
18601 // debug statements here
18603 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18605 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
18606 if(!isWasmInitialized) {
18607 throw new Error("initializeWasm() must be awaited first!");
18609 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
18610 return nativeResponseValue;
18612 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
18614 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
18615 if(!isWasmInitialized) {
18616 throw new Error("initializeWasm() must be awaited first!");
18618 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
18619 // debug statements here
18621 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18623 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
18624 if(!isWasmInitialized) {
18625 throw new Error("initializeWasm() must be awaited first!");
18627 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
18628 return nativeResponseValue;
18630 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
18632 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
18633 if(!isWasmInitialized) {
18634 throw new Error("initializeWasm() must be awaited first!");
18636 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
18637 // debug statements here
18639 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18641 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
18642 if(!isWasmInitialized) {
18643 throw new Error("initializeWasm() must be awaited first!");
18645 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
18646 return nativeResponseValue;
18648 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
18650 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
18651 if(!isWasmInitialized) {
18652 throw new Error("initializeWasm() must be awaited first!");
18654 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
18655 // debug statements here
18657 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18659 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
18660 if(!isWasmInitialized) {
18661 throw new Error("initializeWasm() must be awaited first!");
18663 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
18664 return nativeResponseValue;
18666 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
18668 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
18669 if(!isWasmInitialized) {
18670 throw new Error("initializeWasm() must be awaited first!");
18672 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
18673 // debug statements here
18675 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18677 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
18678 if(!isWasmInitialized) {
18679 throw new Error("initializeWasm() must be awaited first!");
18681 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
18682 return nativeResponseValue;
18684 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
18686 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
18687 if(!isWasmInitialized) {
18688 throw new Error("initializeWasm() must be awaited first!");
18690 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
18691 // debug statements here
18693 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18695 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
18696 if(!isWasmInitialized) {
18697 throw new Error("initializeWasm() must be awaited first!");
18699 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
18700 return nativeResponseValue;
18702 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
18704 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
18705 if(!isWasmInitialized) {
18706 throw new Error("initializeWasm() must be awaited first!");
18708 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
18709 // debug statements here
18711 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18713 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
18714 if(!isWasmInitialized) {
18715 throw new Error("initializeWasm() must be awaited first!");
18717 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
18718 return nativeResponseValue;
18720 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
18722 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
18723 if(!isWasmInitialized) {
18724 throw new Error("initializeWasm() must be awaited first!");
18726 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
18727 // debug statements here
18729 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
18731 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
18732 if(!isWasmInitialized) {
18733 throw new Error("initializeWasm() must be awaited first!");
18735 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
18736 return nativeResponseValue;
18738 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
18740 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
18741 if(!isWasmInitialized) {
18742 throw new Error("initializeWasm() must be awaited first!");
18744 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
18745 // debug statements here
18747 // 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, uint32_t their_channel_reserve_proportional_millionths_arg);
18749 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, their_channel_reserve_proportional_millionths_arg: number): bigint {
18750 if(!isWasmInitialized) {
18751 throw new Error("initializeWasm() must be awaited first!");
18753 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, their_channel_reserve_proportional_millionths_arg);
18754 return nativeResponseValue;
18756 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
18758 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
18759 if(!isWasmInitialized) {
18760 throw new Error("initializeWasm() must be awaited first!");
18762 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
18763 return nativeResponseValue;
18765 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
18767 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
18768 if(!isWasmInitialized) {
18769 throw new Error("initializeWasm() must be awaited first!");
18771 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
18772 return nativeResponseValue;
18774 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
18776 export function ChannelHandshakeConfig_default(): bigint {
18777 if(!isWasmInitialized) {
18778 throw new Error("initializeWasm() must be awaited first!");
18780 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
18781 return nativeResponseValue;
18783 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
18785 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
18786 if(!isWasmInitialized) {
18787 throw new Error("initializeWasm() must be awaited first!");
18789 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
18790 // debug statements here
18792 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18794 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
18795 if(!isWasmInitialized) {
18796 throw new Error("initializeWasm() must be awaited first!");
18798 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
18799 return nativeResponseValue;
18801 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18803 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
18804 if(!isWasmInitialized) {
18805 throw new Error("initializeWasm() must be awaited first!");
18807 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
18808 // debug statements here
18810 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18812 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
18813 if(!isWasmInitialized) {
18814 throw new Error("initializeWasm() must be awaited first!");
18816 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
18817 return nativeResponseValue;
18819 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18821 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
18822 if(!isWasmInitialized) {
18823 throw new Error("initializeWasm() must be awaited first!");
18825 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
18826 // debug statements here
18828 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18830 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
18831 if(!isWasmInitialized) {
18832 throw new Error("initializeWasm() must be awaited first!");
18834 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
18835 return nativeResponseValue;
18837 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18839 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
18840 if(!isWasmInitialized) {
18841 throw new Error("initializeWasm() must be awaited first!");
18843 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
18844 // debug statements here
18846 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18848 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
18849 if(!isWasmInitialized) {
18850 throw new Error("initializeWasm() must be awaited first!");
18852 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
18853 return nativeResponseValue;
18855 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18857 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
18858 if(!isWasmInitialized) {
18859 throw new Error("initializeWasm() must be awaited first!");
18861 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
18862 // debug statements here
18864 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18866 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
18867 if(!isWasmInitialized) {
18868 throw new Error("initializeWasm() must be awaited first!");
18870 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
18871 return nativeResponseValue;
18873 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
18875 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
18876 if(!isWasmInitialized) {
18877 throw new Error("initializeWasm() must be awaited first!");
18879 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
18880 // debug statements here
18882 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18884 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
18885 if(!isWasmInitialized) {
18886 throw new Error("initializeWasm() must be awaited first!");
18888 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
18889 return nativeResponseValue;
18891 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
18893 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
18894 if(!isWasmInitialized) {
18895 throw new Error("initializeWasm() must be awaited first!");
18897 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
18898 // debug statements here
18900 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18902 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
18903 if(!isWasmInitialized) {
18904 throw new Error("initializeWasm() must be awaited first!");
18906 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
18907 return nativeResponseValue;
18909 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
18911 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
18912 if(!isWasmInitialized) {
18913 throw new Error("initializeWasm() must be awaited first!");
18915 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
18916 // debug statements here
18918 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18920 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
18921 if(!isWasmInitialized) {
18922 throw new Error("initializeWasm() must be awaited first!");
18924 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
18925 return nativeResponseValue;
18927 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
18929 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
18930 if(!isWasmInitialized) {
18931 throw new Error("initializeWasm() must be awaited first!");
18933 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
18934 // debug statements here
18936 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18938 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
18939 if(!isWasmInitialized) {
18940 throw new Error("initializeWasm() must be awaited first!");
18942 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
18943 return nativeResponseValue;
18945 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
18947 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
18948 if(!isWasmInitialized) {
18949 throw new Error("initializeWasm() must be awaited first!");
18951 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
18952 // debug statements here
18954 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
18956 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
18957 if(!isWasmInitialized) {
18958 throw new Error("initializeWasm() must be awaited first!");
18960 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
18961 return nativeResponseValue;
18963 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
18965 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
18966 if(!isWasmInitialized) {
18967 throw new Error("initializeWasm() must be awaited first!");
18969 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
18970 // debug statements here
18972 // 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);
18974 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): bigint {
18975 if(!isWasmInitialized) {
18976 throw new Error("initializeWasm() must be awaited first!");
18978 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);
18979 return nativeResponseValue;
18981 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
18983 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
18984 if(!isWasmInitialized) {
18985 throw new Error("initializeWasm() must be awaited first!");
18987 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
18988 return nativeResponseValue;
18990 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
18992 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
18993 if(!isWasmInitialized) {
18994 throw new Error("initializeWasm() must be awaited first!");
18996 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
18997 return nativeResponseValue;
18999 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
19001 export function ChannelHandshakeLimits_default(): bigint {
19002 if(!isWasmInitialized) {
19003 throw new Error("initializeWasm() must be awaited first!");
19005 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
19006 return nativeResponseValue;
19008 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
19010 export function ChannelConfig_free(this_obj: bigint): void {
19011 if(!isWasmInitialized) {
19012 throw new Error("initializeWasm() must be awaited first!");
19014 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
19015 // debug statements here
19017 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19019 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
19020 if(!isWasmInitialized) {
19021 throw new Error("initializeWasm() must be awaited first!");
19023 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
19024 return nativeResponseValue;
19026 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
19028 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
19029 if(!isWasmInitialized) {
19030 throw new Error("initializeWasm() must be awaited first!");
19032 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
19033 // debug statements here
19035 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19037 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
19038 if(!isWasmInitialized) {
19039 throw new Error("initializeWasm() must be awaited first!");
19041 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
19042 return nativeResponseValue;
19044 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
19046 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
19047 if(!isWasmInitialized) {
19048 throw new Error("initializeWasm() must be awaited first!");
19050 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
19051 // debug statements here
19053 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19055 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
19056 if(!isWasmInitialized) {
19057 throw new Error("initializeWasm() must be awaited first!");
19059 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
19060 return nativeResponseValue;
19062 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
19064 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
19065 if(!isWasmInitialized) {
19066 throw new Error("initializeWasm() must be awaited first!");
19068 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
19069 // debug statements here
19071 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19073 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
19074 if(!isWasmInitialized) {
19075 throw new Error("initializeWasm() must be awaited first!");
19077 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
19078 return nativeResponseValue;
19080 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
19082 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
19083 if(!isWasmInitialized) {
19084 throw new Error("initializeWasm() must be awaited first!");
19086 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
19087 // debug statements here
19089 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
19091 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
19092 if(!isWasmInitialized) {
19093 throw new Error("initializeWasm() must be awaited first!");
19095 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
19096 return nativeResponseValue;
19098 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
19100 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
19101 if(!isWasmInitialized) {
19102 throw new Error("initializeWasm() must be awaited first!");
19104 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
19105 // debug statements here
19107 // 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);
19109 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): bigint {
19110 if(!isWasmInitialized) {
19111 throw new Error("initializeWasm() must be awaited first!");
19113 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);
19114 return nativeResponseValue;
19116 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
19118 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
19119 if(!isWasmInitialized) {
19120 throw new Error("initializeWasm() must be awaited first!");
19122 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
19123 return nativeResponseValue;
19125 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
19127 export function ChannelConfig_clone(orig: bigint): bigint {
19128 if(!isWasmInitialized) {
19129 throw new Error("initializeWasm() must be awaited first!");
19131 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
19132 return nativeResponseValue;
19134 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
19136 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
19137 if(!isWasmInitialized) {
19138 throw new Error("initializeWasm() must be awaited first!");
19140 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
19141 return nativeResponseValue;
19143 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
19145 export function ChannelConfig_default(): bigint {
19146 if(!isWasmInitialized) {
19147 throw new Error("initializeWasm() must be awaited first!");
19149 const nativeResponseValue = wasm.TS_ChannelConfig_default();
19150 return nativeResponseValue;
19152 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
19154 export function ChannelConfig_write(obj: bigint): number {
19155 if(!isWasmInitialized) {
19156 throw new Error("initializeWasm() must be awaited first!");
19158 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
19159 return nativeResponseValue;
19161 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
19163 export function ChannelConfig_read(ser: number): bigint {
19164 if(!isWasmInitialized) {
19165 throw new Error("initializeWasm() must be awaited first!");
19167 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
19168 return nativeResponseValue;
19170 // void UserConfig_free(struct LDKUserConfig this_obj);
19172 export function UserConfig_free(this_obj: bigint): void {
19173 if(!isWasmInitialized) {
19174 throw new Error("initializeWasm() must be awaited first!");
19176 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
19177 // debug statements here
19179 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19181 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
19182 if(!isWasmInitialized) {
19183 throw new Error("initializeWasm() must be awaited first!");
19185 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
19186 return nativeResponseValue;
19188 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
19190 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
19191 if(!isWasmInitialized) {
19192 throw new Error("initializeWasm() must be awaited first!");
19194 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
19195 // debug statements here
19197 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19199 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
19200 if(!isWasmInitialized) {
19201 throw new Error("initializeWasm() must be awaited first!");
19203 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
19204 return nativeResponseValue;
19206 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
19208 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
19209 if(!isWasmInitialized) {
19210 throw new Error("initializeWasm() must be awaited first!");
19212 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
19213 // debug statements here
19215 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19217 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
19218 if(!isWasmInitialized) {
19219 throw new Error("initializeWasm() must be awaited first!");
19221 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
19222 return nativeResponseValue;
19224 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19226 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
19227 if(!isWasmInitialized) {
19228 throw new Error("initializeWasm() must be awaited first!");
19230 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
19231 // debug statements here
19233 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19235 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
19236 if(!isWasmInitialized) {
19237 throw new Error("initializeWasm() must be awaited first!");
19239 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
19240 return nativeResponseValue;
19242 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19244 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
19245 if(!isWasmInitialized) {
19246 throw new Error("initializeWasm() must be awaited first!");
19248 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
19249 // debug statements here
19251 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19253 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
19254 if(!isWasmInitialized) {
19255 throw new Error("initializeWasm() must be awaited first!");
19257 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
19258 return nativeResponseValue;
19260 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19262 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
19263 if(!isWasmInitialized) {
19264 throw new Error("initializeWasm() must be awaited first!");
19266 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
19267 // debug statements here
19269 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19271 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
19272 if(!isWasmInitialized) {
19273 throw new Error("initializeWasm() must be awaited first!");
19275 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
19276 return nativeResponseValue;
19278 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19280 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
19281 if(!isWasmInitialized) {
19282 throw new Error("initializeWasm() must be awaited first!");
19284 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
19285 // debug statements here
19287 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
19289 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
19290 if(!isWasmInitialized) {
19291 throw new Error("initializeWasm() must be awaited first!");
19293 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
19294 return nativeResponseValue;
19296 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
19298 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
19299 if(!isWasmInitialized) {
19300 throw new Error("initializeWasm() must be awaited first!");
19302 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
19303 // debug statements here
19305 // 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, bool accept_intercept_htlcs_arg);
19307 export function UserConfig_new(channel_handshake_config_arg: bigint, channel_handshake_limits_arg: bigint, channel_config_arg: bigint, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean, accept_intercept_htlcs_arg: boolean): bigint {
19308 if(!isWasmInitialized) {
19309 throw new Error("initializeWasm() must be awaited first!");
19311 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, accept_intercept_htlcs_arg);
19312 return nativeResponseValue;
19314 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
19316 export function UserConfig_clone_ptr(arg: bigint): bigint {
19317 if(!isWasmInitialized) {
19318 throw new Error("initializeWasm() must be awaited first!");
19320 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
19321 return nativeResponseValue;
19323 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
19325 export function UserConfig_clone(orig: bigint): bigint {
19326 if(!isWasmInitialized) {
19327 throw new Error("initializeWasm() must be awaited first!");
19329 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
19330 return nativeResponseValue;
19332 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
19334 export function UserConfig_default(): bigint {
19335 if(!isWasmInitialized) {
19336 throw new Error("initializeWasm() must be awaited first!");
19338 const nativeResponseValue = wasm.TS_UserConfig_default();
19339 return nativeResponseValue;
19341 // void BestBlock_free(struct LDKBestBlock this_obj);
19343 export function BestBlock_free(this_obj: bigint): void {
19344 if(!isWasmInitialized) {
19345 throw new Error("initializeWasm() must be awaited first!");
19347 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
19348 // debug statements here
19350 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
19352 export function BestBlock_clone_ptr(arg: bigint): bigint {
19353 if(!isWasmInitialized) {
19354 throw new Error("initializeWasm() must be awaited first!");
19356 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
19357 return nativeResponseValue;
19359 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
19361 export function BestBlock_clone(orig: bigint): bigint {
19362 if(!isWasmInitialized) {
19363 throw new Error("initializeWasm() must be awaited first!");
19365 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
19366 return nativeResponseValue;
19368 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
19370 export function BestBlock_eq(a: bigint, b: bigint): boolean {
19371 if(!isWasmInitialized) {
19372 throw new Error("initializeWasm() must be awaited first!");
19374 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
19375 return nativeResponseValue;
19377 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
19379 export function BestBlock_from_genesis(network: Network): bigint {
19380 if(!isWasmInitialized) {
19381 throw new Error("initializeWasm() must be awaited first!");
19383 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
19384 return nativeResponseValue;
19386 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
19388 export function BestBlock_new(block_hash: number, height: number): bigint {
19389 if(!isWasmInitialized) {
19390 throw new Error("initializeWasm() must be awaited first!");
19392 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
19393 return nativeResponseValue;
19395 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
19397 export function BestBlock_block_hash(this_arg: bigint): number {
19398 if(!isWasmInitialized) {
19399 throw new Error("initializeWasm() must be awaited first!");
19401 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
19402 return nativeResponseValue;
19404 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
19406 export function BestBlock_height(this_arg: bigint): number {
19407 if(!isWasmInitialized) {
19408 throw new Error("initializeWasm() must be awaited first!");
19410 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
19411 return nativeResponseValue;
19413 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
19415 export function AccessError_clone(orig: bigint): AccessError {
19416 if(!isWasmInitialized) {
19417 throw new Error("initializeWasm() must be awaited first!");
19419 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
19420 return nativeResponseValue;
19422 // enum LDKAccessError AccessError_unknown_chain(void);
19424 export function AccessError_unknown_chain(): AccessError {
19425 if(!isWasmInitialized) {
19426 throw new Error("initializeWasm() must be awaited first!");
19428 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
19429 return nativeResponseValue;
19431 // enum LDKAccessError AccessError_unknown_tx(void);
19433 export function AccessError_unknown_tx(): AccessError {
19434 if(!isWasmInitialized) {
19435 throw new Error("initializeWasm() must be awaited first!");
19437 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
19438 return nativeResponseValue;
19440 // void Access_free(struct LDKAccess this_ptr);
19442 export function Access_free(this_ptr: bigint): void {
19443 if(!isWasmInitialized) {
19444 throw new Error("initializeWasm() must be awaited first!");
19446 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
19447 // debug statements here
19449 // void Listen_free(struct LDKListen this_ptr);
19451 export function Listen_free(this_ptr: bigint): void {
19452 if(!isWasmInitialized) {
19453 throw new Error("initializeWasm() must be awaited first!");
19455 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
19456 // debug statements here
19458 // void Confirm_free(struct LDKConfirm this_ptr);
19460 export function Confirm_free(this_ptr: bigint): void {
19461 if(!isWasmInitialized) {
19462 throw new Error("initializeWasm() must be awaited first!");
19464 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
19465 // debug statements here
19467 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
19469 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
19470 if(!isWasmInitialized) {
19471 throw new Error("initializeWasm() must be awaited first!");
19473 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
19474 return nativeResponseValue;
19476 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
19478 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
19479 if(!isWasmInitialized) {
19480 throw new Error("initializeWasm() must be awaited first!");
19482 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
19483 return nativeResponseValue;
19485 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
19487 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
19488 if(!isWasmInitialized) {
19489 throw new Error("initializeWasm() must be awaited first!");
19491 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
19492 return nativeResponseValue;
19494 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_permanent_failure(void);
19496 export function ChannelMonitorUpdateStatus_permanent_failure(): ChannelMonitorUpdateStatus {
19497 if(!isWasmInitialized) {
19498 throw new Error("initializeWasm() must be awaited first!");
19500 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_permanent_failure();
19501 return nativeResponseValue;
19503 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
19505 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
19506 if(!isWasmInitialized) {
19507 throw new Error("initializeWasm() must be awaited first!");
19509 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
19510 return nativeResponseValue;
19512 // void Watch_free(struct LDKWatch this_ptr);
19514 export function Watch_free(this_ptr: bigint): void {
19515 if(!isWasmInitialized) {
19516 throw new Error("initializeWasm() must be awaited first!");
19518 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
19519 // debug statements here
19521 // void Filter_free(struct LDKFilter this_ptr);
19523 export function Filter_free(this_ptr: bigint): void {
19524 if(!isWasmInitialized) {
19525 throw new Error("initializeWasm() must be awaited first!");
19527 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
19528 // debug statements here
19530 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
19532 export function WatchedOutput_free(this_obj: bigint): void {
19533 if(!isWasmInitialized) {
19534 throw new Error("initializeWasm() must be awaited first!");
19536 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
19537 // debug statements here
19539 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
19541 export function WatchedOutput_get_block_hash(this_ptr: bigint): number {
19542 if(!isWasmInitialized) {
19543 throw new Error("initializeWasm() must be awaited first!");
19545 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
19546 return nativeResponseValue;
19548 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19550 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: number): void {
19551 if(!isWasmInitialized) {
19552 throw new Error("initializeWasm() must be awaited first!");
19554 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
19555 // debug statements here
19557 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
19559 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
19560 if(!isWasmInitialized) {
19561 throw new Error("initializeWasm() must be awaited first!");
19563 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
19564 return nativeResponseValue;
19566 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19568 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
19569 if(!isWasmInitialized) {
19570 throw new Error("initializeWasm() must be awaited first!");
19572 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
19573 // debug statements here
19575 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
19577 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
19578 if(!isWasmInitialized) {
19579 throw new Error("initializeWasm() must be awaited first!");
19581 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
19582 return nativeResponseValue;
19584 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
19586 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
19587 if(!isWasmInitialized) {
19588 throw new Error("initializeWasm() must be awaited first!");
19590 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
19591 // debug statements here
19593 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
19595 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
19596 if(!isWasmInitialized) {
19597 throw new Error("initializeWasm() must be awaited first!");
19599 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
19600 return nativeResponseValue;
19602 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
19604 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
19605 if(!isWasmInitialized) {
19606 throw new Error("initializeWasm() must be awaited first!");
19608 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
19609 return nativeResponseValue;
19611 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
19613 export function WatchedOutput_clone(orig: bigint): bigint {
19614 if(!isWasmInitialized) {
19615 throw new Error("initializeWasm() must be awaited first!");
19617 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
19618 return nativeResponseValue;
19620 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
19622 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
19623 if(!isWasmInitialized) {
19624 throw new Error("initializeWasm() must be awaited first!");
19626 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
19627 return nativeResponseValue;
19629 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
19631 export function WatchedOutput_hash(o: bigint): bigint {
19632 if(!isWasmInitialized) {
19633 throw new Error("initializeWasm() must be awaited first!");
19635 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
19636 return nativeResponseValue;
19638 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
19640 export function BroadcasterInterface_free(this_ptr: bigint): void {
19641 if(!isWasmInitialized) {
19642 throw new Error("initializeWasm() must be awaited first!");
19644 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
19645 // debug statements here
19647 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
19649 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
19650 if(!isWasmInitialized) {
19651 throw new Error("initializeWasm() must be awaited first!");
19653 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
19654 return nativeResponseValue;
19656 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
19658 export function ConfirmationTarget_background(): ConfirmationTarget {
19659 if(!isWasmInitialized) {
19660 throw new Error("initializeWasm() must be awaited first!");
19662 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
19663 return nativeResponseValue;
19665 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
19667 export function ConfirmationTarget_normal(): ConfirmationTarget {
19668 if(!isWasmInitialized) {
19669 throw new Error("initializeWasm() must be awaited first!");
19671 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
19672 return nativeResponseValue;
19674 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
19676 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
19677 if(!isWasmInitialized) {
19678 throw new Error("initializeWasm() must be awaited first!");
19680 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
19681 return nativeResponseValue;
19683 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
19685 export function ConfirmationTarget_hash(o: bigint): bigint {
19686 if(!isWasmInitialized) {
19687 throw new Error("initializeWasm() must be awaited first!");
19689 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
19690 return nativeResponseValue;
19692 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
19694 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
19695 if(!isWasmInitialized) {
19696 throw new Error("initializeWasm() must be awaited first!");
19698 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
19699 return nativeResponseValue;
19701 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
19703 export function FeeEstimator_free(this_ptr: bigint): void {
19704 if(!isWasmInitialized) {
19705 throw new Error("initializeWasm() must be awaited first!");
19707 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
19708 // debug statements here
19710 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
19712 export function MonitorUpdateId_free(this_obj: bigint): void {
19713 if(!isWasmInitialized) {
19714 throw new Error("initializeWasm() must be awaited first!");
19716 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
19717 // debug statements here
19719 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
19721 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
19722 if(!isWasmInitialized) {
19723 throw new Error("initializeWasm() must be awaited first!");
19725 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
19726 return nativeResponseValue;
19728 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
19730 export function MonitorUpdateId_clone(orig: bigint): bigint {
19731 if(!isWasmInitialized) {
19732 throw new Error("initializeWasm() must be awaited first!");
19734 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
19735 return nativeResponseValue;
19737 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
19739 export function MonitorUpdateId_hash(o: bigint): bigint {
19740 if(!isWasmInitialized) {
19741 throw new Error("initializeWasm() must be awaited first!");
19743 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
19744 return nativeResponseValue;
19746 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
19748 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
19749 if(!isWasmInitialized) {
19750 throw new Error("initializeWasm() must be awaited first!");
19752 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
19753 return nativeResponseValue;
19755 // void Persist_free(struct LDKPersist this_ptr);
19757 export function Persist_free(this_ptr: bigint): void {
19758 if(!isWasmInitialized) {
19759 throw new Error("initializeWasm() must be awaited first!");
19761 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
19762 // debug statements here
19764 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
19766 export function LockedChannelMonitor_free(this_obj: bigint): void {
19767 if(!isWasmInitialized) {
19768 throw new Error("initializeWasm() must be awaited first!");
19770 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
19771 // debug statements here
19773 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
19775 export function ChainMonitor_free(this_obj: bigint): void {
19776 if(!isWasmInitialized) {
19777 throw new Error("initializeWasm() must be awaited first!");
19779 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
19780 // debug statements here
19782 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
19784 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
19785 if(!isWasmInitialized) {
19786 throw new Error("initializeWasm() must be awaited first!");
19788 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
19789 return nativeResponseValue;
19791 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
19793 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
19794 if(!isWasmInitialized) {
19795 throw new Error("initializeWasm() must be awaited first!");
19797 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
19798 return nativeResponseValue;
19800 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
19802 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
19803 if(!isWasmInitialized) {
19804 throw new Error("initializeWasm() must be awaited first!");
19806 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
19807 return nativeResponseValue;
19809 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19811 export function ChainMonitor_list_monitors(this_arg: bigint): number {
19812 if(!isWasmInitialized) {
19813 throw new Error("initializeWasm() must be awaited first!");
19815 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
19816 return nativeResponseValue;
19818 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19820 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
19821 if(!isWasmInitialized) {
19822 throw new Error("initializeWasm() must be awaited first!");
19824 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
19825 return nativeResponseValue;
19827 // 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);
19829 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
19830 if(!isWasmInitialized) {
19831 throw new Error("initializeWasm() must be awaited first!");
19833 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
19834 return nativeResponseValue;
19836 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19838 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
19839 if(!isWasmInitialized) {
19840 throw new Error("initializeWasm() must be awaited first!");
19842 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
19843 return nativeResponseValue;
19845 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19847 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
19848 if(!isWasmInitialized) {
19849 throw new Error("initializeWasm() must be awaited first!");
19851 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
19852 return nativeResponseValue;
19854 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19856 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
19857 if(!isWasmInitialized) {
19858 throw new Error("initializeWasm() must be awaited first!");
19860 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
19861 return nativeResponseValue;
19863 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
19865 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
19866 if(!isWasmInitialized) {
19867 throw new Error("initializeWasm() must be awaited first!");
19869 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
19870 return nativeResponseValue;
19872 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
19874 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
19875 if(!isWasmInitialized) {
19876 throw new Error("initializeWasm() must be awaited first!");
19878 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
19879 // debug statements here
19881 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
19883 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
19884 if(!isWasmInitialized) {
19885 throw new Error("initializeWasm() must be awaited first!");
19887 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
19888 return nativeResponseValue;
19890 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
19892 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
19893 if(!isWasmInitialized) {
19894 throw new Error("initializeWasm() must be awaited first!");
19896 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
19897 // debug statements here
19899 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
19901 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
19902 if(!isWasmInitialized) {
19903 throw new Error("initializeWasm() must be awaited first!");
19905 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
19906 return nativeResponseValue;
19908 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
19910 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
19911 if(!isWasmInitialized) {
19912 throw new Error("initializeWasm() must be awaited first!");
19914 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
19915 return nativeResponseValue;
19917 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
19919 export function ChannelMonitorUpdate_write(obj: bigint): number {
19920 if(!isWasmInitialized) {
19921 throw new Error("initializeWasm() must be awaited first!");
19923 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
19924 return nativeResponseValue;
19926 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
19928 export function ChannelMonitorUpdate_read(ser: number): bigint {
19929 if(!isWasmInitialized) {
19930 throw new Error("initializeWasm() must be awaited first!");
19932 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
19933 return nativeResponseValue;
19935 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
19937 export function MonitorEvent_free(this_ptr: bigint): void {
19938 if(!isWasmInitialized) {
19939 throw new Error("initializeWasm() must be awaited first!");
19941 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
19942 // debug statements here
19944 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
19946 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
19947 if(!isWasmInitialized) {
19948 throw new Error("initializeWasm() must be awaited first!");
19950 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
19951 return nativeResponseValue;
19953 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
19955 export function MonitorEvent_clone(orig: bigint): bigint {
19956 if(!isWasmInitialized) {
19957 throw new Error("initializeWasm() must be awaited first!");
19959 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
19960 return nativeResponseValue;
19962 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
19964 export function MonitorEvent_htlcevent(a: bigint): bigint {
19965 if(!isWasmInitialized) {
19966 throw new Error("initializeWasm() must be awaited first!");
19968 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
19969 return nativeResponseValue;
19971 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
19973 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
19974 if(!isWasmInitialized) {
19975 throw new Error("initializeWasm() must be awaited first!");
19977 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
19978 return nativeResponseValue;
19980 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
19982 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
19983 if(!isWasmInitialized) {
19984 throw new Error("initializeWasm() must be awaited first!");
19986 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
19987 return nativeResponseValue;
19989 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
19991 export function MonitorEvent_update_failed(a: bigint): bigint {
19992 if(!isWasmInitialized) {
19993 throw new Error("initializeWasm() must be awaited first!");
19995 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
19996 return nativeResponseValue;
19998 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
20000 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
20001 if(!isWasmInitialized) {
20002 throw new Error("initializeWasm() must be awaited first!");
20004 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
20005 return nativeResponseValue;
20007 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
20009 export function MonitorEvent_write(obj: bigint): number {
20010 if(!isWasmInitialized) {
20011 throw new Error("initializeWasm() must be awaited first!");
20013 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
20014 return nativeResponseValue;
20016 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
20018 export function MonitorEvent_read(ser: number): bigint {
20019 if(!isWasmInitialized) {
20020 throw new Error("initializeWasm() must be awaited first!");
20022 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
20023 return nativeResponseValue;
20025 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
20027 export function HTLCUpdate_free(this_obj: bigint): void {
20028 if(!isWasmInitialized) {
20029 throw new Error("initializeWasm() must be awaited first!");
20031 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
20032 // debug statements here
20034 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
20036 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
20037 if(!isWasmInitialized) {
20038 throw new Error("initializeWasm() must be awaited first!");
20040 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
20041 return nativeResponseValue;
20043 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
20045 export function HTLCUpdate_clone(orig: bigint): bigint {
20046 if(!isWasmInitialized) {
20047 throw new Error("initializeWasm() must be awaited first!");
20049 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
20050 return nativeResponseValue;
20052 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
20054 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
20055 if(!isWasmInitialized) {
20056 throw new Error("initializeWasm() must be awaited first!");
20058 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
20059 return nativeResponseValue;
20061 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
20063 export function HTLCUpdate_write(obj: bigint): number {
20064 if(!isWasmInitialized) {
20065 throw new Error("initializeWasm() must be awaited first!");
20067 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
20068 return nativeResponseValue;
20070 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
20072 export function HTLCUpdate_read(ser: number): bigint {
20073 if(!isWasmInitialized) {
20074 throw new Error("initializeWasm() must be awaited first!");
20076 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
20077 return nativeResponseValue;
20079 // void Balance_free(struct LDKBalance this_ptr);
20081 export function Balance_free(this_ptr: bigint): void {
20082 if(!isWasmInitialized) {
20083 throw new Error("initializeWasm() must be awaited first!");
20085 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
20086 // debug statements here
20088 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
20090 export function Balance_clone_ptr(arg: bigint): bigint {
20091 if(!isWasmInitialized) {
20092 throw new Error("initializeWasm() must be awaited first!");
20094 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
20095 return nativeResponseValue;
20097 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
20099 export function Balance_clone(orig: bigint): bigint {
20100 if(!isWasmInitialized) {
20101 throw new Error("initializeWasm() must be awaited first!");
20103 const nativeResponseValue = wasm.TS_Balance_clone(orig);
20104 return nativeResponseValue;
20106 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
20108 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): bigint {
20109 if(!isWasmInitialized) {
20110 throw new Error("initializeWasm() must be awaited first!");
20112 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
20113 return nativeResponseValue;
20115 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
20117 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): bigint {
20118 if(!isWasmInitialized) {
20119 throw new Error("initializeWasm() must be awaited first!");
20121 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
20122 return nativeResponseValue;
20124 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
20126 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): bigint {
20127 if(!isWasmInitialized) {
20128 throw new Error("initializeWasm() must be awaited first!");
20130 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
20131 return nativeResponseValue;
20133 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
20135 export function Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis: bigint, claimable_height: number): bigint {
20136 if(!isWasmInitialized) {
20137 throw new Error("initializeWasm() must be awaited first!");
20139 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
20140 return nativeResponseValue;
20142 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t claimable_amount_satoshis, uint32_t expiry_height);
20144 export function Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis: bigint, expiry_height: number): bigint {
20145 if(!isWasmInitialized) {
20146 throw new Error("initializeWasm() must be awaited first!");
20148 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
20149 return nativeResponseValue;
20151 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t claimable_amount_satoshis);
20153 export function Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis: bigint): bigint {
20154 if(!isWasmInitialized) {
20155 throw new Error("initializeWasm() must be awaited first!");
20157 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
20158 return nativeResponseValue;
20160 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
20162 export function Balance_eq(a: bigint, b: bigint): boolean {
20163 if(!isWasmInitialized) {
20164 throw new Error("initializeWasm() must be awaited first!");
20166 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
20167 return nativeResponseValue;
20169 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
20171 export function ChannelMonitor_free(this_obj: bigint): void {
20172 if(!isWasmInitialized) {
20173 throw new Error("initializeWasm() must be awaited first!");
20175 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
20176 // debug statements here
20178 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
20180 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
20181 if(!isWasmInitialized) {
20182 throw new Error("initializeWasm() must be awaited first!");
20184 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
20185 return nativeResponseValue;
20187 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
20189 export function ChannelMonitor_clone(orig: bigint): bigint {
20190 if(!isWasmInitialized) {
20191 throw new Error("initializeWasm() must be awaited first!");
20193 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
20194 return nativeResponseValue;
20196 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
20198 export function ChannelMonitor_write(obj: bigint): number {
20199 if(!isWasmInitialized) {
20200 throw new Error("initializeWasm() must be awaited first!");
20202 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
20203 return nativeResponseValue;
20205 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
20207 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
20208 if(!isWasmInitialized) {
20209 throw new Error("initializeWasm() must be awaited first!");
20211 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
20212 return nativeResponseValue;
20214 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20216 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
20217 if(!isWasmInitialized) {
20218 throw new Error("initializeWasm() must be awaited first!");
20220 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
20221 return nativeResponseValue;
20223 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20225 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
20226 if(!isWasmInitialized) {
20227 throw new Error("initializeWasm() must be awaited first!");
20229 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
20230 return nativeResponseValue;
20232 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20234 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
20235 if(!isWasmInitialized) {
20236 throw new Error("initializeWasm() must be awaited first!");
20238 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
20239 return nativeResponseValue;
20241 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
20243 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
20244 if(!isWasmInitialized) {
20245 throw new Error("initializeWasm() must be awaited first!");
20247 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
20248 // debug statements here
20250 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20252 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
20253 if(!isWasmInitialized) {
20254 throw new Error("initializeWasm() must be awaited first!");
20256 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
20257 return nativeResponseValue;
20259 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20261 export function ChannelMonitor_get_and_clear_pending_events(this_arg: bigint): number {
20262 if(!isWasmInitialized) {
20263 throw new Error("initializeWasm() must be awaited first!");
20265 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
20266 return nativeResponseValue;
20268 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20270 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
20271 if(!isWasmInitialized) {
20272 throw new Error("initializeWasm() must be awaited first!");
20274 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
20275 return nativeResponseValue;
20277 // 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);
20279 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
20280 if(!isWasmInitialized) {
20281 throw new Error("initializeWasm() must be awaited first!");
20283 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
20284 return nativeResponseValue;
20286 // 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);
20288 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20289 if(!isWasmInitialized) {
20290 throw new Error("initializeWasm() must be awaited first!");
20292 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
20293 return nativeResponseValue;
20295 // 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);
20297 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
20298 if(!isWasmInitialized) {
20299 throw new Error("initializeWasm() must be awaited first!");
20301 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
20302 // debug statements here
20304 // 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);
20306 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20307 if(!isWasmInitialized) {
20308 throw new Error("initializeWasm() must be awaited first!");
20310 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
20311 return nativeResponseValue;
20313 // 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);
20315 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
20316 if(!isWasmInitialized) {
20317 throw new Error("initializeWasm() must be awaited first!");
20319 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
20320 // debug statements here
20322 // 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);
20324 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
20325 if(!isWasmInitialized) {
20326 throw new Error("initializeWasm() must be awaited first!");
20328 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
20329 return nativeResponseValue;
20331 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidBlockHashZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20333 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
20334 if(!isWasmInitialized) {
20335 throw new Error("initializeWasm() must be awaited first!");
20337 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
20338 return nativeResponseValue;
20340 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20342 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
20343 if(!isWasmInitialized) {
20344 throw new Error("initializeWasm() must be awaited first!");
20346 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
20347 return nativeResponseValue;
20349 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
20351 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
20352 if(!isWasmInitialized) {
20353 throw new Error("initializeWasm() must be awaited first!");
20355 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
20356 return nativeResponseValue;
20358 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
20360 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: bigint): bigint {
20361 if(!isWasmInitialized) {
20362 throw new Error("initializeWasm() must be awaited first!");
20364 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
20365 return nativeResponseValue;
20367 // void OutPoint_free(struct LDKOutPoint this_obj);
20369 export function OutPoint_free(this_obj: bigint): void {
20370 if(!isWasmInitialized) {
20371 throw new Error("initializeWasm() must be awaited first!");
20373 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
20374 // debug statements here
20376 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
20378 export function OutPoint_get_txid(this_ptr: bigint): number {
20379 if(!isWasmInitialized) {
20380 throw new Error("initializeWasm() must be awaited first!");
20382 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
20383 return nativeResponseValue;
20385 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20387 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
20388 if(!isWasmInitialized) {
20389 throw new Error("initializeWasm() must be awaited first!");
20391 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
20392 // debug statements here
20394 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
20396 export function OutPoint_get_index(this_ptr: bigint): number {
20397 if(!isWasmInitialized) {
20398 throw new Error("initializeWasm() must be awaited first!");
20400 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
20401 return nativeResponseValue;
20403 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
20405 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
20406 if(!isWasmInitialized) {
20407 throw new Error("initializeWasm() must be awaited first!");
20409 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
20410 // debug statements here
20412 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
20414 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
20415 if(!isWasmInitialized) {
20416 throw new Error("initializeWasm() must be awaited first!");
20418 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
20419 return nativeResponseValue;
20421 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
20423 export function OutPoint_clone_ptr(arg: bigint): bigint {
20424 if(!isWasmInitialized) {
20425 throw new Error("initializeWasm() must be awaited first!");
20427 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
20428 return nativeResponseValue;
20430 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
20432 export function OutPoint_clone(orig: bigint): bigint {
20433 if(!isWasmInitialized) {
20434 throw new Error("initializeWasm() must be awaited first!");
20436 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
20437 return nativeResponseValue;
20439 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
20441 export function OutPoint_eq(a: bigint, b: bigint): boolean {
20442 if(!isWasmInitialized) {
20443 throw new Error("initializeWasm() must be awaited first!");
20445 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
20446 return nativeResponseValue;
20448 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
20450 export function OutPoint_hash(o: bigint): bigint {
20451 if(!isWasmInitialized) {
20452 throw new Error("initializeWasm() must be awaited first!");
20454 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
20455 return nativeResponseValue;
20457 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
20459 export function OutPoint_to_channel_id(this_arg: bigint): number {
20460 if(!isWasmInitialized) {
20461 throw new Error("initializeWasm() must be awaited first!");
20463 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
20464 return nativeResponseValue;
20466 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
20468 export function OutPoint_write(obj: bigint): number {
20469 if(!isWasmInitialized) {
20470 throw new Error("initializeWasm() must be awaited first!");
20472 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
20473 return nativeResponseValue;
20475 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
20477 export function OutPoint_read(ser: number): bigint {
20478 if(!isWasmInitialized) {
20479 throw new Error("initializeWasm() must be awaited first!");
20481 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
20482 return nativeResponseValue;
20484 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
20486 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
20487 if(!isWasmInitialized) {
20488 throw new Error("initializeWasm() must be awaited first!");
20490 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
20491 // debug statements here
20493 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20495 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
20496 if(!isWasmInitialized) {
20497 throw new Error("initializeWasm() must be awaited first!");
20499 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
20500 return nativeResponseValue;
20502 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
20504 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
20505 if(!isWasmInitialized) {
20506 throw new Error("initializeWasm() must be awaited first!");
20508 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
20509 // debug statements here
20511 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20513 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
20514 if(!isWasmInitialized) {
20515 throw new Error("initializeWasm() must be awaited first!");
20517 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
20518 return nativeResponseValue;
20520 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20522 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
20523 if(!isWasmInitialized) {
20524 throw new Error("initializeWasm() must be awaited first!");
20526 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
20527 // debug statements here
20529 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20531 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
20532 if(!isWasmInitialized) {
20533 throw new Error("initializeWasm() must be awaited first!");
20535 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
20536 return nativeResponseValue;
20538 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
20540 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
20541 if(!isWasmInitialized) {
20542 throw new Error("initializeWasm() must be awaited first!");
20544 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
20545 // debug statements here
20547 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20549 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
20550 if(!isWasmInitialized) {
20551 throw new Error("initializeWasm() must be awaited first!");
20553 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
20554 return nativeResponseValue;
20556 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
20558 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
20559 if(!isWasmInitialized) {
20560 throw new Error("initializeWasm() must be awaited first!");
20562 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
20563 // debug statements here
20565 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20567 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
20568 if(!isWasmInitialized) {
20569 throw new Error("initializeWasm() must be awaited first!");
20571 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
20572 return nativeResponseValue;
20574 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20576 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
20577 if(!isWasmInitialized) {
20578 throw new Error("initializeWasm() must be awaited first!");
20580 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
20581 // debug statements here
20583 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
20585 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
20586 if(!isWasmInitialized) {
20587 throw new Error("initializeWasm() must be awaited first!");
20589 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
20590 return nativeResponseValue;
20592 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20594 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
20595 if(!isWasmInitialized) {
20596 throw new Error("initializeWasm() must be awaited first!");
20598 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
20599 // debug statements here
20601 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20603 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
20604 if(!isWasmInitialized) {
20605 throw new Error("initializeWasm() must be awaited first!");
20607 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
20608 return nativeResponseValue;
20610 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
20612 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
20613 if(!isWasmInitialized) {
20614 throw new Error("initializeWasm() must be awaited first!");
20616 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
20617 // debug statements here
20619 // 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);
20621 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: bigint, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: bigint, revocation_pubkey_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
20622 if(!isWasmInitialized) {
20623 throw new Error("initializeWasm() must be awaited first!");
20625 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);
20626 return nativeResponseValue;
20628 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
20630 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
20631 if(!isWasmInitialized) {
20632 throw new Error("initializeWasm() must be awaited first!");
20634 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
20635 return nativeResponseValue;
20637 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
20639 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
20640 if(!isWasmInitialized) {
20641 throw new Error("initializeWasm() must be awaited first!");
20643 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
20644 return nativeResponseValue;
20646 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
20648 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
20649 if(!isWasmInitialized) {
20650 throw new Error("initializeWasm() must be awaited first!");
20652 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
20653 return nativeResponseValue;
20655 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
20657 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
20658 if(!isWasmInitialized) {
20659 throw new Error("initializeWasm() must be awaited first!");
20661 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
20662 return nativeResponseValue;
20664 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
20666 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
20667 if(!isWasmInitialized) {
20668 throw new Error("initializeWasm() must be awaited first!");
20670 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
20671 return nativeResponseValue;
20673 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
20675 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
20676 if(!isWasmInitialized) {
20677 throw new Error("initializeWasm() must be awaited first!");
20679 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
20680 // debug statements here
20682 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20684 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
20685 if(!isWasmInitialized) {
20686 throw new Error("initializeWasm() must be awaited first!");
20688 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
20689 return nativeResponseValue;
20691 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
20693 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
20694 if(!isWasmInitialized) {
20695 throw new Error("initializeWasm() must be awaited first!");
20697 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
20698 // debug statements here
20700 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20702 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
20703 if(!isWasmInitialized) {
20704 throw new Error("initializeWasm() must be awaited first!");
20706 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
20707 return nativeResponseValue;
20709 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
20711 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
20712 if(!isWasmInitialized) {
20713 throw new Error("initializeWasm() must be awaited first!");
20715 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
20716 // debug statements here
20718 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
20720 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
20721 if(!isWasmInitialized) {
20722 throw new Error("initializeWasm() must be awaited first!");
20724 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
20725 return nativeResponseValue;
20727 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20729 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
20730 if(!isWasmInitialized) {
20731 throw new Error("initializeWasm() must be awaited first!");
20733 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
20734 // debug statements here
20736 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
20738 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
20739 if(!isWasmInitialized) {
20740 throw new Error("initializeWasm() must be awaited first!");
20742 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
20743 return nativeResponseValue;
20745 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
20747 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
20748 if(!isWasmInitialized) {
20749 throw new Error("initializeWasm() must be awaited first!");
20751 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
20752 // debug statements here
20754 // 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);
20756 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
20757 if(!isWasmInitialized) {
20758 throw new Error("initializeWasm() must be awaited first!");
20760 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
20761 return nativeResponseValue;
20763 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
20765 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
20766 if(!isWasmInitialized) {
20767 throw new Error("initializeWasm() must be awaited first!");
20769 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
20770 return nativeResponseValue;
20772 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
20774 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
20775 if(!isWasmInitialized) {
20776 throw new Error("initializeWasm() must be awaited first!");
20778 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
20779 return nativeResponseValue;
20781 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
20783 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
20784 if(!isWasmInitialized) {
20785 throw new Error("initializeWasm() must be awaited first!");
20787 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
20788 return nativeResponseValue;
20790 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
20792 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
20793 if(!isWasmInitialized) {
20794 throw new Error("initializeWasm() must be awaited first!");
20796 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
20797 return nativeResponseValue;
20799 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
20801 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
20802 if(!isWasmInitialized) {
20803 throw new Error("initializeWasm() must be awaited first!");
20805 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
20806 return nativeResponseValue;
20808 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
20810 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
20811 if(!isWasmInitialized) {
20812 throw new Error("initializeWasm() must be awaited first!");
20814 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
20815 // debug statements here
20817 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
20819 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
20820 if(!isWasmInitialized) {
20821 throw new Error("initializeWasm() must be awaited first!");
20823 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
20824 return nativeResponseValue;
20826 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
20828 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
20829 if(!isWasmInitialized) {
20830 throw new Error("initializeWasm() must be awaited first!");
20832 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
20833 return nativeResponseValue;
20835 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
20837 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
20838 if(!isWasmInitialized) {
20839 throw new Error("initializeWasm() must be awaited first!");
20841 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
20842 return nativeResponseValue;
20844 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
20846 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
20847 if(!isWasmInitialized) {
20848 throw new Error("initializeWasm() must be awaited first!");
20850 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
20851 return nativeResponseValue;
20853 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
20855 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
20856 if(!isWasmInitialized) {
20857 throw new Error("initializeWasm() must be awaited first!");
20859 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
20860 return nativeResponseValue;
20862 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
20864 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
20865 if(!isWasmInitialized) {
20866 throw new Error("initializeWasm() must be awaited first!");
20868 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
20869 return nativeResponseValue;
20871 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
20873 export function SpendableOutputDescriptor_write(obj: bigint): number {
20874 if(!isWasmInitialized) {
20875 throw new Error("initializeWasm() must be awaited first!");
20877 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
20878 return nativeResponseValue;
20880 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
20882 export function SpendableOutputDescriptor_read(ser: number): bigint {
20883 if(!isWasmInitialized) {
20884 throw new Error("initializeWasm() must be awaited first!");
20886 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
20887 return nativeResponseValue;
20889 // void BaseSign_free(struct LDKBaseSign this_ptr);
20891 export function BaseSign_free(this_ptr: bigint): void {
20892 if(!isWasmInitialized) {
20893 throw new Error("initializeWasm() must be awaited first!");
20895 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
20896 // debug statements here
20898 // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
20900 export function Sign_clone_ptr(arg: bigint): bigint {
20901 if(!isWasmInitialized) {
20902 throw new Error("initializeWasm() must be awaited first!");
20904 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
20905 return nativeResponseValue;
20907 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
20909 export function Sign_clone(orig: bigint): bigint {
20910 if(!isWasmInitialized) {
20911 throw new Error("initializeWasm() must be awaited first!");
20913 const nativeResponseValue = wasm.TS_Sign_clone(orig);
20914 return nativeResponseValue;
20916 // void Sign_free(struct LDKSign this_ptr);
20918 export function Sign_free(this_ptr: bigint): void {
20919 if(!isWasmInitialized) {
20920 throw new Error("initializeWasm() must be awaited first!");
20922 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
20923 // debug statements here
20925 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
20927 export function Recipient_clone(orig: bigint): Recipient {
20928 if(!isWasmInitialized) {
20929 throw new Error("initializeWasm() must be awaited first!");
20931 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
20932 return nativeResponseValue;
20934 // enum LDKRecipient Recipient_node(void);
20936 export function Recipient_node(): Recipient {
20937 if(!isWasmInitialized) {
20938 throw new Error("initializeWasm() must be awaited first!");
20940 const nativeResponseValue = wasm.TS_Recipient_node();
20941 return nativeResponseValue;
20943 // enum LDKRecipient Recipient_phantom_node(void);
20945 export function Recipient_phantom_node(): Recipient {
20946 if(!isWasmInitialized) {
20947 throw new Error("initializeWasm() must be awaited first!");
20949 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
20950 return nativeResponseValue;
20952 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
20954 export function KeysInterface_free(this_ptr: bigint): void {
20955 if(!isWasmInitialized) {
20956 throw new Error("initializeWasm() must be awaited first!");
20958 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
20959 // debug statements here
20961 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
20963 export function InMemorySigner_free(this_obj: bigint): void {
20964 if(!isWasmInitialized) {
20965 throw new Error("initializeWasm() must be awaited first!");
20967 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
20968 // debug statements here
20970 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20972 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
20973 if(!isWasmInitialized) {
20974 throw new Error("initializeWasm() must be awaited first!");
20976 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
20977 return nativeResponseValue;
20979 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20981 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
20982 if(!isWasmInitialized) {
20983 throw new Error("initializeWasm() must be awaited first!");
20985 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
20986 // debug statements here
20988 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
20990 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
20991 if(!isWasmInitialized) {
20992 throw new Error("initializeWasm() must be awaited first!");
20994 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
20995 return nativeResponseValue;
20997 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
20999 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
21000 if(!isWasmInitialized) {
21001 throw new Error("initializeWasm() must be awaited first!");
21003 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
21004 // debug statements here
21006 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21008 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
21009 if(!isWasmInitialized) {
21010 throw new Error("initializeWasm() must be awaited first!");
21012 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
21013 return nativeResponseValue;
21015 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21017 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
21018 if(!isWasmInitialized) {
21019 throw new Error("initializeWasm() must be awaited first!");
21021 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
21022 // debug statements here
21024 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21026 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
21027 if(!isWasmInitialized) {
21028 throw new Error("initializeWasm() must be awaited first!");
21030 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
21031 return nativeResponseValue;
21033 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21035 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
21036 if(!isWasmInitialized) {
21037 throw new Error("initializeWasm() must be awaited first!");
21039 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
21040 // debug statements here
21042 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21044 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
21045 if(!isWasmInitialized) {
21046 throw new Error("initializeWasm() must be awaited first!");
21048 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
21049 return nativeResponseValue;
21051 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
21053 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
21054 if(!isWasmInitialized) {
21055 throw new Error("initializeWasm() must be awaited first!");
21057 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
21058 // debug statements here
21060 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
21062 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
21063 if(!isWasmInitialized) {
21064 throw new Error("initializeWasm() must be awaited first!");
21066 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
21067 return nativeResponseValue;
21069 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21071 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
21072 if(!isWasmInitialized) {
21073 throw new Error("initializeWasm() must be awaited first!");
21075 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
21076 // debug statements here
21078 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
21080 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
21081 if(!isWasmInitialized) {
21082 throw new Error("initializeWasm() must be awaited first!");
21084 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
21085 return nativeResponseValue;
21087 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
21089 export function InMemorySigner_clone(orig: bigint): bigint {
21090 if(!isWasmInitialized) {
21091 throw new Error("initializeWasm() must be awaited first!");
21093 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
21094 return nativeResponseValue;
21096 // 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);
21098 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): bigint {
21099 if(!isWasmInitialized) {
21100 throw new Error("initializeWasm() must be awaited first!");
21102 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);
21103 return nativeResponseValue;
21105 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21107 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
21108 if(!isWasmInitialized) {
21109 throw new Error("initializeWasm() must be awaited first!");
21111 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
21112 return nativeResponseValue;
21114 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21116 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
21117 if(!isWasmInitialized) {
21118 throw new Error("initializeWasm() must be awaited first!");
21120 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
21121 return nativeResponseValue;
21123 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21125 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
21126 if(!isWasmInitialized) {
21127 throw new Error("initializeWasm() must be awaited first!");
21129 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
21130 return nativeResponseValue;
21132 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21134 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
21135 if(!isWasmInitialized) {
21136 throw new Error("initializeWasm() must be awaited first!");
21138 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
21139 return nativeResponseValue;
21141 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21143 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
21144 if(!isWasmInitialized) {
21145 throw new Error("initializeWasm() must be awaited first!");
21147 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
21148 return nativeResponseValue;
21150 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21152 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
21153 if(!isWasmInitialized) {
21154 throw new Error("initializeWasm() must be awaited first!");
21156 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
21157 return nativeResponseValue;
21159 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21161 export function InMemorySigner_opt_anchors(this_arg: bigint): boolean {
21162 if(!isWasmInitialized) {
21163 throw new Error("initializeWasm() must be awaited first!");
21165 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
21166 return nativeResponseValue;
21168 // 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);
21170 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
21171 if(!isWasmInitialized) {
21172 throw new Error("initializeWasm() must be awaited first!");
21174 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
21175 return nativeResponseValue;
21177 // 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);
21179 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
21180 if(!isWasmInitialized) {
21181 throw new Error("initializeWasm() must be awaited first!");
21183 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
21184 return nativeResponseValue;
21186 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21188 export function InMemorySigner_as_BaseSign(this_arg: bigint): bigint {
21189 if(!isWasmInitialized) {
21190 throw new Error("initializeWasm() must be awaited first!");
21192 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
21193 return nativeResponseValue;
21195 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
21197 export function InMemorySigner_as_Sign(this_arg: bigint): bigint {
21198 if(!isWasmInitialized) {
21199 throw new Error("initializeWasm() must be awaited first!");
21201 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
21202 return nativeResponseValue;
21204 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
21206 export function InMemorySigner_write(obj: bigint): number {
21207 if(!isWasmInitialized) {
21208 throw new Error("initializeWasm() must be awaited first!");
21210 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
21211 return nativeResponseValue;
21213 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
21215 export function InMemorySigner_read(ser: number, arg: number): bigint {
21216 if(!isWasmInitialized) {
21217 throw new Error("initializeWasm() must be awaited first!");
21219 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
21220 return nativeResponseValue;
21222 // void KeysManager_free(struct LDKKeysManager this_obj);
21224 export function KeysManager_free(this_obj: bigint): void {
21225 if(!isWasmInitialized) {
21226 throw new Error("initializeWasm() must be awaited first!");
21228 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
21229 // debug statements here
21231 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
21233 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
21234 if(!isWasmInitialized) {
21235 throw new Error("initializeWasm() must be awaited first!");
21237 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
21238 return nativeResponseValue;
21240 // 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]);
21242 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
21243 if(!isWasmInitialized) {
21244 throw new Error("initializeWasm() must be awaited first!");
21246 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
21247 return nativeResponseValue;
21249 // 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);
21251 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
21252 if(!isWasmInitialized) {
21253 throw new Error("initializeWasm() must be awaited first!");
21255 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
21256 return nativeResponseValue;
21258 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
21260 export function KeysManager_as_KeysInterface(this_arg: bigint): bigint {
21261 if(!isWasmInitialized) {
21262 throw new Error("initializeWasm() must be awaited first!");
21264 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
21265 return nativeResponseValue;
21267 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
21269 export function PhantomKeysManager_free(this_obj: bigint): void {
21270 if(!isWasmInitialized) {
21271 throw new Error("initializeWasm() must be awaited first!");
21273 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
21274 // debug statements here
21276 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
21278 export function PhantomKeysManager_as_KeysInterface(this_arg: bigint): bigint {
21279 if(!isWasmInitialized) {
21280 throw new Error("initializeWasm() must be awaited first!");
21282 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
21283 return nativeResponseValue;
21285 // 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]);
21287 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
21288 if(!isWasmInitialized) {
21289 throw new Error("initializeWasm() must be awaited first!");
21291 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
21292 return nativeResponseValue;
21294 // 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);
21296 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
21297 if(!isWasmInitialized) {
21298 throw new Error("initializeWasm() must be awaited first!");
21300 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
21301 return nativeResponseValue;
21303 // 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]);
21305 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
21306 if(!isWasmInitialized) {
21307 throw new Error("initializeWasm() must be awaited first!");
21309 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
21310 return nativeResponseValue;
21312 // void ChannelManager_free(struct LDKChannelManager this_obj);
21314 export function ChannelManager_free(this_obj: bigint): void {
21315 if(!isWasmInitialized) {
21316 throw new Error("initializeWasm() must be awaited first!");
21318 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
21319 // debug statements here
21321 // void ChainParameters_free(struct LDKChainParameters this_obj);
21323 export function ChainParameters_free(this_obj: bigint): void {
21324 if(!isWasmInitialized) {
21325 throw new Error("initializeWasm() must be awaited first!");
21327 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
21328 // debug statements here
21330 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
21332 export function ChainParameters_get_network(this_ptr: bigint): Network {
21333 if(!isWasmInitialized) {
21334 throw new Error("initializeWasm() must be awaited first!");
21336 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
21337 return nativeResponseValue;
21339 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
21341 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
21342 if(!isWasmInitialized) {
21343 throw new Error("initializeWasm() must be awaited first!");
21345 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
21346 // debug statements here
21348 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
21350 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
21351 if(!isWasmInitialized) {
21352 throw new Error("initializeWasm() must be awaited first!");
21354 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
21355 return nativeResponseValue;
21357 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
21359 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
21360 if(!isWasmInitialized) {
21361 throw new Error("initializeWasm() must be awaited first!");
21363 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
21364 // debug statements here
21366 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
21368 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
21369 if(!isWasmInitialized) {
21370 throw new Error("initializeWasm() must be awaited first!");
21372 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
21373 return nativeResponseValue;
21375 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
21377 export function ChainParameters_clone_ptr(arg: bigint): bigint {
21378 if(!isWasmInitialized) {
21379 throw new Error("initializeWasm() must be awaited first!");
21381 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
21382 return nativeResponseValue;
21384 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
21386 export function ChainParameters_clone(orig: bigint): bigint {
21387 if(!isWasmInitialized) {
21388 throw new Error("initializeWasm() must be awaited first!");
21390 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
21391 return nativeResponseValue;
21393 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
21395 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
21396 if(!isWasmInitialized) {
21397 throw new Error("initializeWasm() must be awaited first!");
21399 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
21400 // debug statements here
21402 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
21404 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
21405 if(!isWasmInitialized) {
21406 throw new Error("initializeWasm() must be awaited first!");
21408 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
21409 return nativeResponseValue;
21411 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
21413 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
21414 if(!isWasmInitialized) {
21415 throw new Error("initializeWasm() must be awaited first!");
21417 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
21418 // debug statements here
21420 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
21422 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
21423 if(!isWasmInitialized) {
21424 throw new Error("initializeWasm() must be awaited first!");
21426 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
21427 return nativeResponseValue;
21429 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
21431 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
21432 if(!isWasmInitialized) {
21433 throw new Error("initializeWasm() must be awaited first!");
21435 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
21436 // debug statements here
21438 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
21440 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
21441 if(!isWasmInitialized) {
21442 throw new Error("initializeWasm() must be awaited first!");
21444 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
21445 return nativeResponseValue;
21447 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
21449 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
21450 if(!isWasmInitialized) {
21451 throw new Error("initializeWasm() must be awaited first!");
21453 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
21454 // debug statements here
21456 // 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);
21458 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
21459 if(!isWasmInitialized) {
21460 throw new Error("initializeWasm() must be awaited first!");
21462 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
21463 return nativeResponseValue;
21465 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
21467 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
21468 if(!isWasmInitialized) {
21469 throw new Error("initializeWasm() must be awaited first!");
21471 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
21472 return nativeResponseValue;
21474 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
21476 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
21477 if(!isWasmInitialized) {
21478 throw new Error("initializeWasm() must be awaited first!");
21480 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
21481 return nativeResponseValue;
21483 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
21485 export function ChannelCounterparty_free(this_obj: bigint): void {
21486 if(!isWasmInitialized) {
21487 throw new Error("initializeWasm() must be awaited first!");
21489 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
21490 // debug statements here
21492 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21494 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
21495 if(!isWasmInitialized) {
21496 throw new Error("initializeWasm() must be awaited first!");
21498 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
21499 return nativeResponseValue;
21501 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21503 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
21504 if(!isWasmInitialized) {
21505 throw new Error("initializeWasm() must be awaited first!");
21507 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
21508 // debug statements here
21510 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21512 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
21513 if(!isWasmInitialized) {
21514 throw new Error("initializeWasm() must be awaited first!");
21516 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
21517 return nativeResponseValue;
21519 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
21521 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
21522 if(!isWasmInitialized) {
21523 throw new Error("initializeWasm() must be awaited first!");
21525 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
21526 // debug statements here
21528 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21530 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
21531 if(!isWasmInitialized) {
21532 throw new Error("initializeWasm() must be awaited first!");
21534 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
21535 return nativeResponseValue;
21537 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
21539 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
21540 if(!isWasmInitialized) {
21541 throw new Error("initializeWasm() must be awaited first!");
21543 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
21544 // debug statements here
21546 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21548 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
21549 if(!isWasmInitialized) {
21550 throw new Error("initializeWasm() must be awaited first!");
21552 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
21553 return nativeResponseValue;
21555 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
21557 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
21558 if(!isWasmInitialized) {
21559 throw new Error("initializeWasm() must be awaited first!");
21561 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
21562 // debug statements here
21564 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21566 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
21567 if(!isWasmInitialized) {
21568 throw new Error("initializeWasm() must be awaited first!");
21570 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
21571 return nativeResponseValue;
21573 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21575 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
21576 if(!isWasmInitialized) {
21577 throw new Error("initializeWasm() must be awaited first!");
21579 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
21580 // debug statements here
21582 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
21584 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
21585 if(!isWasmInitialized) {
21586 throw new Error("initializeWasm() must be awaited first!");
21588 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
21589 return nativeResponseValue;
21591 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21593 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
21594 if(!isWasmInitialized) {
21595 throw new Error("initializeWasm() must be awaited first!");
21597 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
21598 // debug statements here
21600 // 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);
21602 export function ChannelCounterparty_new(node_id_arg: number, features_arg: bigint, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: bigint, outbound_htlc_minimum_msat_arg: bigint, outbound_htlc_maximum_msat_arg: bigint): bigint {
21603 if(!isWasmInitialized) {
21604 throw new Error("initializeWasm() must be awaited first!");
21606 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);
21607 return nativeResponseValue;
21609 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
21611 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
21612 if(!isWasmInitialized) {
21613 throw new Error("initializeWasm() must be awaited first!");
21615 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
21616 return nativeResponseValue;
21618 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
21620 export function ChannelCounterparty_clone(orig: bigint): bigint {
21621 if(!isWasmInitialized) {
21622 throw new Error("initializeWasm() must be awaited first!");
21624 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
21625 return nativeResponseValue;
21627 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
21629 export function ChannelDetails_free(this_obj: bigint): void {
21630 if(!isWasmInitialized) {
21631 throw new Error("initializeWasm() must be awaited first!");
21633 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
21634 // debug statements here
21636 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
21638 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
21639 if(!isWasmInitialized) {
21640 throw new Error("initializeWasm() must be awaited first!");
21642 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
21643 return nativeResponseValue;
21645 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21647 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
21648 if(!isWasmInitialized) {
21649 throw new Error("initializeWasm() must be awaited first!");
21651 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
21652 // debug statements here
21654 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21656 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
21657 if(!isWasmInitialized) {
21658 throw new Error("initializeWasm() must be awaited first!");
21660 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
21661 return nativeResponseValue;
21663 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
21665 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
21666 if(!isWasmInitialized) {
21667 throw new Error("initializeWasm() must be awaited first!");
21669 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
21670 // debug statements here
21672 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21674 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
21675 if(!isWasmInitialized) {
21676 throw new Error("initializeWasm() must be awaited first!");
21678 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
21679 return nativeResponseValue;
21681 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
21683 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
21684 if(!isWasmInitialized) {
21685 throw new Error("initializeWasm() must be awaited first!");
21687 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
21688 // debug statements here
21690 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21692 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
21693 if(!isWasmInitialized) {
21694 throw new Error("initializeWasm() must be awaited first!");
21696 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
21697 return nativeResponseValue;
21699 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21701 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
21702 if(!isWasmInitialized) {
21703 throw new Error("initializeWasm() must be awaited first!");
21705 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
21706 // debug statements here
21708 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21710 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
21711 if(!isWasmInitialized) {
21712 throw new Error("initializeWasm() must be awaited first!");
21714 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
21715 return nativeResponseValue;
21717 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21719 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
21720 if(!isWasmInitialized) {
21721 throw new Error("initializeWasm() must be awaited first!");
21723 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
21724 // debug statements here
21726 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21728 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
21729 if(!isWasmInitialized) {
21730 throw new Error("initializeWasm() must be awaited first!");
21732 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
21733 return nativeResponseValue;
21735 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21737 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
21738 if(!isWasmInitialized) {
21739 throw new Error("initializeWasm() must be awaited first!");
21741 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
21742 // debug statements here
21744 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21746 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
21747 if(!isWasmInitialized) {
21748 throw new Error("initializeWasm() must be awaited first!");
21750 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
21751 return nativeResponseValue;
21753 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21755 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
21756 if(!isWasmInitialized) {
21757 throw new Error("initializeWasm() must be awaited first!");
21759 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
21760 // debug statements here
21762 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21764 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
21765 if(!isWasmInitialized) {
21766 throw new Error("initializeWasm() must be awaited first!");
21768 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
21769 return nativeResponseValue;
21771 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21773 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
21774 if(!isWasmInitialized) {
21775 throw new Error("initializeWasm() must be awaited first!");
21777 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
21778 // debug statements here
21780 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21782 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
21783 if(!isWasmInitialized) {
21784 throw new Error("initializeWasm() must be awaited first!");
21786 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
21787 return nativeResponseValue;
21789 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21791 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
21792 if(!isWasmInitialized) {
21793 throw new Error("initializeWasm() must be awaited first!");
21795 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
21796 // debug statements here
21798 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21800 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
21801 if(!isWasmInitialized) {
21802 throw new Error("initializeWasm() must be awaited first!");
21804 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
21805 return nativeResponseValue;
21807 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
21809 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
21810 if(!isWasmInitialized) {
21811 throw new Error("initializeWasm() must be awaited first!");
21813 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
21814 // debug statements here
21816 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21818 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
21819 if(!isWasmInitialized) {
21820 throw new Error("initializeWasm() must be awaited first!");
21822 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
21823 return nativeResponseValue;
21825 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21827 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
21828 if(!isWasmInitialized) {
21829 throw new Error("initializeWasm() must be awaited first!");
21831 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
21832 // debug statements here
21834 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21836 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
21837 if(!isWasmInitialized) {
21838 throw new Error("initializeWasm() must be awaited first!");
21840 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
21841 return nativeResponseValue;
21843 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21845 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
21846 if(!isWasmInitialized) {
21847 throw new Error("initializeWasm() must be awaited first!");
21849 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
21850 // debug statements here
21852 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21854 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
21855 if(!isWasmInitialized) {
21856 throw new Error("initializeWasm() must be awaited first!");
21858 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
21859 return nativeResponseValue;
21861 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21863 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
21864 if(!isWasmInitialized) {
21865 throw new Error("initializeWasm() must be awaited first!");
21867 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
21868 // debug statements here
21870 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21872 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
21873 if(!isWasmInitialized) {
21874 throw new Error("initializeWasm() must be awaited first!");
21876 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
21877 return nativeResponseValue;
21879 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
21881 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
21882 if(!isWasmInitialized) {
21883 throw new Error("initializeWasm() must be awaited first!");
21885 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
21886 // debug statements here
21888 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21890 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
21891 if(!isWasmInitialized) {
21892 throw new Error("initializeWasm() must be awaited first!");
21894 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
21895 return nativeResponseValue;
21897 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
21899 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
21900 if(!isWasmInitialized) {
21901 throw new Error("initializeWasm() must be awaited first!");
21903 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
21904 // debug statements here
21906 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21908 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
21909 if(!isWasmInitialized) {
21910 throw new Error("initializeWasm() must be awaited first!");
21912 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
21913 return nativeResponseValue;
21915 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
21917 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
21918 if(!isWasmInitialized) {
21919 throw new Error("initializeWasm() must be awaited first!");
21921 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
21922 // debug statements here
21924 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21926 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
21927 if(!isWasmInitialized) {
21928 throw new Error("initializeWasm() must be awaited first!");
21930 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
21931 return nativeResponseValue;
21933 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
21935 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
21936 if(!isWasmInitialized) {
21937 throw new Error("initializeWasm() must be awaited first!");
21939 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
21940 // debug statements here
21942 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21944 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
21945 if(!isWasmInitialized) {
21946 throw new Error("initializeWasm() must be awaited first!");
21948 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
21949 return nativeResponseValue;
21951 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21953 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
21954 if(!isWasmInitialized) {
21955 throw new Error("initializeWasm() must be awaited first!");
21957 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
21958 // debug statements here
21960 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21962 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
21963 if(!isWasmInitialized) {
21964 throw new Error("initializeWasm() must be awaited first!");
21966 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
21967 return nativeResponseValue;
21969 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21971 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
21972 if(!isWasmInitialized) {
21973 throw new Error("initializeWasm() must be awaited first!");
21975 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
21976 // debug statements here
21978 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21980 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
21981 if(!isWasmInitialized) {
21982 throw new Error("initializeWasm() must be awaited first!");
21984 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
21985 return nativeResponseValue;
21987 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
21989 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
21990 if(!isWasmInitialized) {
21991 throw new Error("initializeWasm() must be awaited first!");
21993 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
21994 // debug statements here
21996 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
21998 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
21999 if(!isWasmInitialized) {
22000 throw new Error("initializeWasm() must be awaited first!");
22002 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
22003 return nativeResponseValue;
22005 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
22007 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
22008 if(!isWasmInitialized) {
22009 throw new Error("initializeWasm() must be awaited first!");
22011 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
22012 // debug statements here
22014 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22016 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
22017 if(!isWasmInitialized) {
22018 throw new Error("initializeWasm() must be awaited first!");
22020 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
22021 return nativeResponseValue;
22023 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22025 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
22026 if(!isWasmInitialized) {
22027 throw new Error("initializeWasm() must be awaited first!");
22029 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
22030 // debug statements here
22032 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22034 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
22035 if(!isWasmInitialized) {
22036 throw new Error("initializeWasm() must be awaited first!");
22038 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
22039 return nativeResponseValue;
22041 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22043 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
22044 if(!isWasmInitialized) {
22045 throw new Error("initializeWasm() must be awaited first!");
22047 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
22048 // debug statements here
22050 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
22052 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
22053 if(!isWasmInitialized) {
22054 throw new Error("initializeWasm() must be awaited first!");
22056 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
22057 return nativeResponseValue;
22059 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
22061 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
22062 if(!isWasmInitialized) {
22063 throw new Error("initializeWasm() must be awaited first!");
22065 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
22066 // debug statements here
22068 // 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, struct LDKU128 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_u32Z confirmations_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);
22070 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: number, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, confirmations_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
22071 if(!isWasmInitialized) {
22072 throw new Error("initializeWasm() must be awaited first!");
22074 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, confirmations_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);
22075 return nativeResponseValue;
22077 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
22079 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
22080 if(!isWasmInitialized) {
22081 throw new Error("initializeWasm() must be awaited first!");
22083 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
22084 return nativeResponseValue;
22086 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
22088 export function ChannelDetails_clone(orig: bigint): bigint {
22089 if(!isWasmInitialized) {
22090 throw new Error("initializeWasm() must be awaited first!");
22092 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
22093 return nativeResponseValue;
22095 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
22097 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
22098 if(!isWasmInitialized) {
22099 throw new Error("initializeWasm() must be awaited first!");
22101 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
22102 return nativeResponseValue;
22104 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
22106 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
22107 if(!isWasmInitialized) {
22108 throw new Error("initializeWasm() must be awaited first!");
22110 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
22111 return nativeResponseValue;
22113 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
22115 export function PaymentSendFailure_free(this_ptr: bigint): void {
22116 if(!isWasmInitialized) {
22117 throw new Error("initializeWasm() must be awaited first!");
22119 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
22120 // debug statements here
22122 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
22124 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
22125 if(!isWasmInitialized) {
22126 throw new Error("initializeWasm() must be awaited first!");
22128 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
22129 return nativeResponseValue;
22131 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
22133 export function PaymentSendFailure_clone(orig: bigint): bigint {
22134 if(!isWasmInitialized) {
22135 throw new Error("initializeWasm() must be awaited first!");
22137 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
22138 return nativeResponseValue;
22140 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
22142 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
22143 if(!isWasmInitialized) {
22144 throw new Error("initializeWasm() must be awaited first!");
22146 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
22147 return nativeResponseValue;
22149 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
22151 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
22152 if(!isWasmInitialized) {
22153 throw new Error("initializeWasm() must be awaited first!");
22155 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
22156 return nativeResponseValue;
22158 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
22160 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
22161 if(!isWasmInitialized) {
22162 throw new Error("initializeWasm() must be awaited first!");
22164 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
22165 return nativeResponseValue;
22167 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
22169 export function PaymentSendFailure_duplicate_payment(): bigint {
22170 if(!isWasmInitialized) {
22171 throw new Error("initializeWasm() must be awaited first!");
22173 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
22174 return nativeResponseValue;
22176 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
22178 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
22179 if(!isWasmInitialized) {
22180 throw new Error("initializeWasm() must be awaited first!");
22182 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
22183 return nativeResponseValue;
22185 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
22187 export function PhantomRouteHints_free(this_obj: bigint): void {
22188 if(!isWasmInitialized) {
22189 throw new Error("initializeWasm() must be awaited first!");
22191 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
22192 // debug statements here
22194 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22196 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
22197 if(!isWasmInitialized) {
22198 throw new Error("initializeWasm() must be awaited first!");
22200 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
22201 return nativeResponseValue;
22203 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
22205 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
22206 if(!isWasmInitialized) {
22207 throw new Error("initializeWasm() must be awaited first!");
22209 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
22210 // debug statements here
22212 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22214 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
22215 if(!isWasmInitialized) {
22216 throw new Error("initializeWasm() must be awaited first!");
22218 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
22219 return nativeResponseValue;
22221 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
22223 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
22224 if(!isWasmInitialized) {
22225 throw new Error("initializeWasm() must be awaited first!");
22227 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
22228 // debug statements here
22230 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
22232 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
22233 if(!isWasmInitialized) {
22234 throw new Error("initializeWasm() must be awaited first!");
22236 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
22237 return nativeResponseValue;
22239 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22241 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
22242 if(!isWasmInitialized) {
22243 throw new Error("initializeWasm() must be awaited first!");
22245 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
22246 // debug statements here
22248 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
22250 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
22251 if(!isWasmInitialized) {
22252 throw new Error("initializeWasm() must be awaited first!");
22254 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
22255 return nativeResponseValue;
22257 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
22259 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
22260 if(!isWasmInitialized) {
22261 throw new Error("initializeWasm() must be awaited first!");
22263 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
22264 return nativeResponseValue;
22266 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
22268 export function PhantomRouteHints_clone(orig: bigint): bigint {
22269 if(!isWasmInitialized) {
22270 throw new Error("initializeWasm() must be awaited first!");
22272 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
22273 return nativeResponseValue;
22275 // 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);
22277 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, keys_manager: bigint, config: bigint, params: bigint): bigint {
22278 if(!isWasmInitialized) {
22279 throw new Error("initializeWasm() must be awaited first!");
22281 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
22282 return nativeResponseValue;
22284 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
22286 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
22287 if(!isWasmInitialized) {
22288 throw new Error("initializeWasm() must be awaited first!");
22290 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
22291 return nativeResponseValue;
22293 // 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, struct LDKU128 user_channel_id, struct LDKUserConfig override_config);
22295 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, override_config: bigint): bigint {
22296 if(!isWasmInitialized) {
22297 throw new Error("initializeWasm() must be awaited first!");
22299 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
22300 return nativeResponseValue;
22302 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
22304 export function ChannelManager_list_channels(this_arg: bigint): number {
22305 if(!isWasmInitialized) {
22306 throw new Error("initializeWasm() must be awaited first!");
22308 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
22309 return nativeResponseValue;
22311 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
22313 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
22314 if(!isWasmInitialized) {
22315 throw new Error("initializeWasm() must be awaited first!");
22317 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
22318 return nativeResponseValue;
22320 // 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);
22322 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
22323 if(!isWasmInitialized) {
22324 throw new Error("initializeWasm() must be awaited first!");
22326 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
22327 return nativeResponseValue;
22329 // 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);
22331 export function ChannelManager_close_channel_with_target_feerate(this_arg: bigint, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: number): bigint {
22332 if(!isWasmInitialized) {
22333 throw new Error("initializeWasm() must be awaited first!");
22335 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
22336 return nativeResponseValue;
22338 // 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);
22340 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
22341 if(!isWasmInitialized) {
22342 throw new Error("initializeWasm() must be awaited first!");
22344 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
22345 return nativeResponseValue;
22347 // 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);
22349 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
22350 if(!isWasmInitialized) {
22351 throw new Error("initializeWasm() must be awaited first!");
22353 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
22354 return nativeResponseValue;
22356 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
22358 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
22359 if(!isWasmInitialized) {
22360 throw new Error("initializeWasm() must be awaited first!");
22362 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
22363 // debug statements here
22365 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
22367 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
22368 if(!isWasmInitialized) {
22369 throw new Error("initializeWasm() must be awaited first!");
22371 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
22372 // debug statements here
22374 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id);
22376 export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number, payment_id: number): bigint {
22377 if(!isWasmInitialized) {
22378 throw new Error("initializeWasm() must be awaited first!");
22380 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret, payment_id);
22381 return nativeResponseValue;
22383 // 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);
22385 export function ChannelManager_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
22386 if(!isWasmInitialized) {
22387 throw new Error("initializeWasm() must be awaited first!");
22389 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
22390 return nativeResponseValue;
22392 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
22394 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
22395 if(!isWasmInitialized) {
22396 throw new Error("initializeWasm() must be awaited first!");
22398 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
22399 // debug statements here
22401 // MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id);
22403 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number, payment_id: number): bigint {
22404 if(!isWasmInitialized) {
22405 throw new Error("initializeWasm() must be awaited first!");
22407 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, payment_id);
22408 return nativeResponseValue;
22410 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
22412 export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
22413 if(!isWasmInitialized) {
22414 throw new Error("initializeWasm() must be awaited first!");
22416 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
22417 return nativeResponseValue;
22419 // 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);
22421 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
22422 if(!isWasmInitialized) {
22423 throw new Error("initializeWasm() must be awaited first!");
22425 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
22426 return nativeResponseValue;
22428 // 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);
22430 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
22431 if(!isWasmInitialized) {
22432 throw new Error("initializeWasm() must be awaited first!");
22434 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
22435 return nativeResponseValue;
22437 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const uint8_t (*next_hop_channel_id)[32], struct LDKPublicKey _next_node_id, uint64_t amt_to_forward_msat);
22439 export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: number, _next_node_id: number, amt_to_forward_msat: bigint): bigint {
22440 if(!isWasmInitialized) {
22441 throw new Error("initializeWasm() must be awaited first!");
22443 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, _next_node_id, amt_to_forward_msat);
22444 return nativeResponseValue;
22446 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
22448 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
22449 if(!isWasmInitialized) {
22450 throw new Error("initializeWasm() must be awaited first!");
22452 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
22453 return nativeResponseValue;
22455 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
22457 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
22458 if(!isWasmInitialized) {
22459 throw new Error("initializeWasm() must be awaited first!");
22461 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
22462 // debug statements here
22464 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
22466 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
22467 if(!isWasmInitialized) {
22468 throw new Error("initializeWasm() must be awaited first!");
22470 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
22471 // debug statements here
22473 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
22475 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
22476 if(!isWasmInitialized) {
22477 throw new Error("initializeWasm() must be awaited first!");
22479 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
22480 // debug statements here
22482 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
22484 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
22485 if(!isWasmInitialized) {
22486 throw new Error("initializeWasm() must be awaited first!");
22488 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
22489 // debug statements here
22491 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
22493 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
22494 if(!isWasmInitialized) {
22495 throw new Error("initializeWasm() must be awaited first!");
22497 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
22498 return nativeResponseValue;
22500 // 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, struct LDKU128 user_channel_id);
22502 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
22503 if(!isWasmInitialized) {
22504 throw new Error("initializeWasm() must be awaited first!");
22506 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
22507 return nativeResponseValue;
22509 // 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, struct LDKU128 user_channel_id);
22511 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
22512 if(!isWasmInitialized) {
22513 throw new Error("initializeWasm() must be awaited first!");
22515 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
22516 return nativeResponseValue;
22518 // 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);
22520 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
22521 if(!isWasmInitialized) {
22522 throw new Error("initializeWasm() must be awaited first!");
22524 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
22525 return nativeResponseValue;
22527 // 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);
22529 export function ChannelManager_create_inbound_payment_legacy(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
22530 if(!isWasmInitialized) {
22531 throw new Error("initializeWasm() must be awaited first!");
22533 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
22534 return nativeResponseValue;
22536 // 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);
22538 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
22539 if(!isWasmInitialized) {
22540 throw new Error("initializeWasm() must be awaited first!");
22542 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
22543 return nativeResponseValue;
22545 // 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);
22547 export function ChannelManager_create_inbound_payment_for_hash_legacy(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
22548 if(!isWasmInitialized) {
22549 throw new Error("initializeWasm() must be awaited first!");
22551 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
22552 return nativeResponseValue;
22554 // 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);
22556 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
22557 if(!isWasmInitialized) {
22558 throw new Error("initializeWasm() must be awaited first!");
22560 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
22561 return nativeResponseValue;
22563 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
22565 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
22566 if(!isWasmInitialized) {
22567 throw new Error("initializeWasm() must be awaited first!");
22569 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
22570 return nativeResponseValue;
22572 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
22574 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
22575 if(!isWasmInitialized) {
22576 throw new Error("initializeWasm() must be awaited first!");
22578 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
22579 return nativeResponseValue;
22581 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
22583 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
22584 if(!isWasmInitialized) {
22585 throw new Error("initializeWasm() must be awaited first!");
22587 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
22588 return nativeResponseValue;
22590 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
22592 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
22593 if(!isWasmInitialized) {
22594 throw new Error("initializeWasm() must be awaited first!");
22596 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
22597 return nativeResponseValue;
22599 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
22601 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
22602 if(!isWasmInitialized) {
22603 throw new Error("initializeWasm() must be awaited first!");
22605 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
22606 return nativeResponseValue;
22608 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
22610 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
22611 if(!isWasmInitialized) {
22612 throw new Error("initializeWasm() must be awaited first!");
22614 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
22615 return nativeResponseValue;
22617 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
22619 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
22620 if(!isWasmInitialized) {
22621 throw new Error("initializeWasm() must be awaited first!");
22623 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
22624 return nativeResponseValue;
22626 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
22628 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
22629 if(!isWasmInitialized) {
22630 throw new Error("initializeWasm() must be awaited first!");
22632 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
22633 return nativeResponseValue;
22635 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
22637 export function ChannelManager_await_persistable_update(this_arg: bigint): void {
22638 if(!isWasmInitialized) {
22639 throw new Error("initializeWasm() must be awaited first!");
22641 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
22642 // debug statements here
22644 // MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
22646 export function ChannelManager_get_persistable_update_future(this_arg: bigint): bigint {
22647 if(!isWasmInitialized) {
22648 throw new Error("initializeWasm() must be awaited first!");
22650 const nativeResponseValue = wasm.TS_ChannelManager_get_persistable_update_future(this_arg);
22651 return nativeResponseValue;
22653 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
22655 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
22656 if(!isWasmInitialized) {
22657 throw new Error("initializeWasm() must be awaited first!");
22659 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
22660 return nativeResponseValue;
22662 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
22664 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
22665 if(!isWasmInitialized) {
22666 throw new Error("initializeWasm() must be awaited first!");
22668 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
22669 return nativeResponseValue;
22671 // struct LDKNodeFeatures provided_node_features(void);
22673 export function provided_node_features(): bigint {
22674 if(!isWasmInitialized) {
22675 throw new Error("initializeWasm() must be awaited first!");
22677 const nativeResponseValue = wasm.TS_provided_node_features();
22678 return nativeResponseValue;
22680 // struct LDKChannelFeatures provided_channel_features(void);
22682 export function provided_channel_features(): bigint {
22683 if(!isWasmInitialized) {
22684 throw new Error("initializeWasm() must be awaited first!");
22686 const nativeResponseValue = wasm.TS_provided_channel_features();
22687 return nativeResponseValue;
22689 // struct LDKInitFeatures provided_init_features(void);
22691 export function provided_init_features(): bigint {
22692 if(!isWasmInitialized) {
22693 throw new Error("initializeWasm() must be awaited first!");
22695 const nativeResponseValue = wasm.TS_provided_init_features();
22696 return nativeResponseValue;
22698 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
22700 export function CounterpartyForwardingInfo_write(obj: bigint): number {
22701 if(!isWasmInitialized) {
22702 throw new Error("initializeWasm() must be awaited first!");
22704 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
22705 return nativeResponseValue;
22707 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
22709 export function CounterpartyForwardingInfo_read(ser: number): bigint {
22710 if(!isWasmInitialized) {
22711 throw new Error("initializeWasm() must be awaited first!");
22713 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
22714 return nativeResponseValue;
22716 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
22718 export function ChannelCounterparty_write(obj: bigint): number {
22719 if(!isWasmInitialized) {
22720 throw new Error("initializeWasm() must be awaited first!");
22722 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
22723 return nativeResponseValue;
22725 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
22727 export function ChannelCounterparty_read(ser: number): bigint {
22728 if(!isWasmInitialized) {
22729 throw new Error("initializeWasm() must be awaited first!");
22731 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
22732 return nativeResponseValue;
22734 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
22736 export function ChannelDetails_write(obj: bigint): number {
22737 if(!isWasmInitialized) {
22738 throw new Error("initializeWasm() must be awaited first!");
22740 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
22741 return nativeResponseValue;
22743 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
22745 export function ChannelDetails_read(ser: number): bigint {
22746 if(!isWasmInitialized) {
22747 throw new Error("initializeWasm() must be awaited first!");
22749 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
22750 return nativeResponseValue;
22752 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
22754 export function PhantomRouteHints_write(obj: bigint): number {
22755 if(!isWasmInitialized) {
22756 throw new Error("initializeWasm() must be awaited first!");
22758 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
22759 return nativeResponseValue;
22761 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
22763 export function PhantomRouteHints_read(ser: number): bigint {
22764 if(!isWasmInitialized) {
22765 throw new Error("initializeWasm() must be awaited first!");
22767 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
22768 return nativeResponseValue;
22770 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
22772 export function ChannelManager_write(obj: bigint): number {
22773 if(!isWasmInitialized) {
22774 throw new Error("initializeWasm() must be awaited first!");
22776 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
22777 return nativeResponseValue;
22779 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
22781 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
22782 if(!isWasmInitialized) {
22783 throw new Error("initializeWasm() must be awaited first!");
22785 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
22786 // debug statements here
22788 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22790 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: bigint): bigint {
22791 if(!isWasmInitialized) {
22792 throw new Error("initializeWasm() must be awaited first!");
22794 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
22795 return nativeResponseValue;
22797 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
22799 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: bigint, val: bigint): void {
22800 if(!isWasmInitialized) {
22801 throw new Error("initializeWasm() must be awaited first!");
22803 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
22804 // debug statements here
22806 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22808 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
22809 if(!isWasmInitialized) {
22810 throw new Error("initializeWasm() must be awaited first!");
22812 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
22813 return nativeResponseValue;
22815 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
22817 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
22818 if(!isWasmInitialized) {
22819 throw new Error("initializeWasm() must be awaited first!");
22821 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
22822 // debug statements here
22824 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22826 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
22827 if(!isWasmInitialized) {
22828 throw new Error("initializeWasm() must be awaited first!");
22830 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
22831 return nativeResponseValue;
22833 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
22835 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
22836 if(!isWasmInitialized) {
22837 throw new Error("initializeWasm() must be awaited first!");
22839 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
22840 // debug statements here
22842 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22844 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
22845 if(!isWasmInitialized) {
22846 throw new Error("initializeWasm() must be awaited first!");
22848 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
22849 return nativeResponseValue;
22851 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
22853 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
22854 if(!isWasmInitialized) {
22855 throw new Error("initializeWasm() must be awaited first!");
22857 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
22858 // debug statements here
22860 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22862 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
22863 if(!isWasmInitialized) {
22864 throw new Error("initializeWasm() must be awaited first!");
22866 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
22867 return nativeResponseValue;
22869 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
22871 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
22872 if(!isWasmInitialized) {
22873 throw new Error("initializeWasm() must be awaited first!");
22875 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
22876 // debug statements here
22878 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
22880 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
22881 if(!isWasmInitialized) {
22882 throw new Error("initializeWasm() must be awaited first!");
22884 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
22885 return nativeResponseValue;
22887 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
22889 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
22890 if(!isWasmInitialized) {
22891 throw new Error("initializeWasm() must be awaited first!");
22893 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
22894 // debug statements here
22896 // 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);
22898 export function ChannelManagerReadArgs_new(keys_manager: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
22899 if(!isWasmInitialized) {
22900 throw new Error("initializeWasm() must be awaited first!");
22902 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
22903 return nativeResponseValue;
22905 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
22907 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
22908 if(!isWasmInitialized) {
22909 throw new Error("initializeWasm() must be awaited first!");
22911 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
22912 return nativeResponseValue;
22914 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
22916 export function ExpandedKey_free(this_obj: bigint): void {
22917 if(!isWasmInitialized) {
22918 throw new Error("initializeWasm() must be awaited first!");
22920 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
22921 // debug statements here
22923 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
22925 export function ExpandedKey_new(key_material: number): bigint {
22926 if(!isWasmInitialized) {
22927 throw new Error("initializeWasm() must be awaited first!");
22929 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
22930 return nativeResponseValue;
22932 // 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);
22934 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, keys_manager: bigint, current_time: bigint): bigint {
22935 if(!isWasmInitialized) {
22936 throw new Error("initializeWasm() must be awaited first!");
22938 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
22939 return nativeResponseValue;
22941 // 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);
22943 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): bigint {
22944 if(!isWasmInitialized) {
22945 throw new Error("initializeWasm() must be awaited first!");
22947 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
22948 return nativeResponseValue;
22950 // void DecodeError_free(struct LDKDecodeError this_ptr);
22952 export function DecodeError_free(this_ptr: bigint): void {
22953 if(!isWasmInitialized) {
22954 throw new Error("initializeWasm() must be awaited first!");
22956 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
22957 // debug statements here
22959 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
22961 export function DecodeError_clone_ptr(arg: bigint): bigint {
22962 if(!isWasmInitialized) {
22963 throw new Error("initializeWasm() must be awaited first!");
22965 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
22966 return nativeResponseValue;
22968 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
22970 export function DecodeError_clone(orig: bigint): bigint {
22971 if(!isWasmInitialized) {
22972 throw new Error("initializeWasm() must be awaited first!");
22974 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
22975 return nativeResponseValue;
22977 // struct LDKDecodeError DecodeError_unknown_version(void);
22979 export function DecodeError_unknown_version(): bigint {
22980 if(!isWasmInitialized) {
22981 throw new Error("initializeWasm() must be awaited first!");
22983 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
22984 return nativeResponseValue;
22986 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
22988 export function DecodeError_unknown_required_feature(): bigint {
22989 if(!isWasmInitialized) {
22990 throw new Error("initializeWasm() must be awaited first!");
22992 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
22993 return nativeResponseValue;
22995 // struct LDKDecodeError DecodeError_invalid_value(void);
22997 export function DecodeError_invalid_value(): bigint {
22998 if(!isWasmInitialized) {
22999 throw new Error("initializeWasm() must be awaited first!");
23001 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
23002 return nativeResponseValue;
23004 // struct LDKDecodeError DecodeError_short_read(void);
23006 export function DecodeError_short_read(): bigint {
23007 if(!isWasmInitialized) {
23008 throw new Error("initializeWasm() must be awaited first!");
23010 const nativeResponseValue = wasm.TS_DecodeError_short_read();
23011 return nativeResponseValue;
23013 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
23015 export function DecodeError_bad_length_descriptor(): bigint {
23016 if(!isWasmInitialized) {
23017 throw new Error("initializeWasm() must be awaited first!");
23019 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
23020 return nativeResponseValue;
23022 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
23024 export function DecodeError_io(a: IOError): bigint {
23025 if(!isWasmInitialized) {
23026 throw new Error("initializeWasm() must be awaited first!");
23028 const nativeResponseValue = wasm.TS_DecodeError_io(a);
23029 return nativeResponseValue;
23031 // struct LDKDecodeError DecodeError_unsupported_compression(void);
23033 export function DecodeError_unsupported_compression(): bigint {
23034 if(!isWasmInitialized) {
23035 throw new Error("initializeWasm() must be awaited first!");
23037 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
23038 return nativeResponseValue;
23040 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
23042 export function DecodeError_eq(a: bigint, b: bigint): boolean {
23043 if(!isWasmInitialized) {
23044 throw new Error("initializeWasm() must be awaited first!");
23046 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
23047 return nativeResponseValue;
23049 // void Init_free(struct LDKInit this_obj);
23051 export function Init_free(this_obj: bigint): void {
23052 if(!isWasmInitialized) {
23053 throw new Error("initializeWasm() must be awaited first!");
23055 const nativeResponseValue = wasm.TS_Init_free(this_obj);
23056 // debug statements here
23058 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
23060 export function Init_get_features(this_ptr: bigint): bigint {
23061 if(!isWasmInitialized) {
23062 throw new Error("initializeWasm() must be awaited first!");
23064 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
23065 return nativeResponseValue;
23067 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
23069 export function Init_set_features(this_ptr: bigint, val: bigint): void {
23070 if(!isWasmInitialized) {
23071 throw new Error("initializeWasm() must be awaited first!");
23073 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
23074 // debug statements here
23076 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
23078 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
23079 if(!isWasmInitialized) {
23080 throw new Error("initializeWasm() must be awaited first!");
23082 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
23083 return nativeResponseValue;
23085 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
23087 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
23088 if(!isWasmInitialized) {
23089 throw new Error("initializeWasm() must be awaited first!");
23091 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
23092 // debug statements here
23094 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
23096 export function Init_new(features_arg: bigint, remote_network_address_arg: bigint): bigint {
23097 if(!isWasmInitialized) {
23098 throw new Error("initializeWasm() must be awaited first!");
23100 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
23101 return nativeResponseValue;
23103 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
23105 export function Init_clone_ptr(arg: bigint): bigint {
23106 if(!isWasmInitialized) {
23107 throw new Error("initializeWasm() must be awaited first!");
23109 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
23110 return nativeResponseValue;
23112 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
23114 export function Init_clone(orig: bigint): bigint {
23115 if(!isWasmInitialized) {
23116 throw new Error("initializeWasm() must be awaited first!");
23118 const nativeResponseValue = wasm.TS_Init_clone(orig);
23119 return nativeResponseValue;
23121 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
23123 export function Init_eq(a: bigint, b: bigint): boolean {
23124 if(!isWasmInitialized) {
23125 throw new Error("initializeWasm() must be awaited first!");
23127 const nativeResponseValue = wasm.TS_Init_eq(a, b);
23128 return nativeResponseValue;
23130 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
23132 export function ErrorMessage_free(this_obj: bigint): void {
23133 if(!isWasmInitialized) {
23134 throw new Error("initializeWasm() must be awaited first!");
23136 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
23137 // debug statements here
23139 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
23141 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
23142 if(!isWasmInitialized) {
23143 throw new Error("initializeWasm() must be awaited first!");
23145 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
23146 return nativeResponseValue;
23148 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23150 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
23151 if(!isWasmInitialized) {
23152 throw new Error("initializeWasm() must be awaited first!");
23154 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
23155 // debug statements here
23157 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
23159 export function ErrorMessage_get_data(this_ptr: bigint): number {
23160 if(!isWasmInitialized) {
23161 throw new Error("initializeWasm() must be awaited first!");
23163 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
23164 return nativeResponseValue;
23166 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
23168 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
23169 if(!isWasmInitialized) {
23170 throw new Error("initializeWasm() must be awaited first!");
23172 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
23173 // debug statements here
23175 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
23177 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
23178 if(!isWasmInitialized) {
23179 throw new Error("initializeWasm() must be awaited first!");
23181 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
23182 return nativeResponseValue;
23184 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
23186 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
23187 if(!isWasmInitialized) {
23188 throw new Error("initializeWasm() must be awaited first!");
23190 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
23191 return nativeResponseValue;
23193 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
23195 export function ErrorMessage_clone(orig: bigint): bigint {
23196 if(!isWasmInitialized) {
23197 throw new Error("initializeWasm() must be awaited first!");
23199 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
23200 return nativeResponseValue;
23202 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
23204 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
23205 if(!isWasmInitialized) {
23206 throw new Error("initializeWasm() must be awaited first!");
23208 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
23209 return nativeResponseValue;
23211 // void WarningMessage_free(struct LDKWarningMessage this_obj);
23213 export function WarningMessage_free(this_obj: bigint): void {
23214 if(!isWasmInitialized) {
23215 throw new Error("initializeWasm() must be awaited first!");
23217 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
23218 // debug statements here
23220 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
23222 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
23223 if(!isWasmInitialized) {
23224 throw new Error("initializeWasm() must be awaited first!");
23226 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
23227 return nativeResponseValue;
23229 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23231 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
23232 if(!isWasmInitialized) {
23233 throw new Error("initializeWasm() must be awaited first!");
23235 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
23236 // debug statements here
23238 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
23240 export function WarningMessage_get_data(this_ptr: bigint): number {
23241 if(!isWasmInitialized) {
23242 throw new Error("initializeWasm() must be awaited first!");
23244 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
23245 return nativeResponseValue;
23247 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
23249 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
23250 if(!isWasmInitialized) {
23251 throw new Error("initializeWasm() must be awaited first!");
23253 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
23254 // debug statements here
23256 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
23258 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
23259 if(!isWasmInitialized) {
23260 throw new Error("initializeWasm() must be awaited first!");
23262 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
23263 return nativeResponseValue;
23265 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
23267 export function WarningMessage_clone_ptr(arg: bigint): bigint {
23268 if(!isWasmInitialized) {
23269 throw new Error("initializeWasm() must be awaited first!");
23271 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
23272 return nativeResponseValue;
23274 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
23276 export function WarningMessage_clone(orig: bigint): bigint {
23277 if(!isWasmInitialized) {
23278 throw new Error("initializeWasm() must be awaited first!");
23280 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
23281 return nativeResponseValue;
23283 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
23285 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
23286 if(!isWasmInitialized) {
23287 throw new Error("initializeWasm() must be awaited first!");
23289 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
23290 return nativeResponseValue;
23292 // void Ping_free(struct LDKPing this_obj);
23294 export function Ping_free(this_obj: bigint): void {
23295 if(!isWasmInitialized) {
23296 throw new Error("initializeWasm() must be awaited first!");
23298 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
23299 // debug statements here
23301 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
23303 export function Ping_get_ponglen(this_ptr: bigint): number {
23304 if(!isWasmInitialized) {
23305 throw new Error("initializeWasm() must be awaited first!");
23307 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
23308 return nativeResponseValue;
23310 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
23312 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
23313 if(!isWasmInitialized) {
23314 throw new Error("initializeWasm() must be awaited first!");
23316 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
23317 // debug statements here
23319 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
23321 export function Ping_get_byteslen(this_ptr: bigint): number {
23322 if(!isWasmInitialized) {
23323 throw new Error("initializeWasm() must be awaited first!");
23325 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
23326 return nativeResponseValue;
23328 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
23330 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
23331 if(!isWasmInitialized) {
23332 throw new Error("initializeWasm() must be awaited first!");
23334 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
23335 // debug statements here
23337 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
23339 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
23340 if(!isWasmInitialized) {
23341 throw new Error("initializeWasm() must be awaited first!");
23343 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
23344 return nativeResponseValue;
23346 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
23348 export function Ping_clone_ptr(arg: bigint): bigint {
23349 if(!isWasmInitialized) {
23350 throw new Error("initializeWasm() must be awaited first!");
23352 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
23353 return nativeResponseValue;
23355 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
23357 export function Ping_clone(orig: bigint): bigint {
23358 if(!isWasmInitialized) {
23359 throw new Error("initializeWasm() must be awaited first!");
23361 const nativeResponseValue = wasm.TS_Ping_clone(orig);
23362 return nativeResponseValue;
23364 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
23366 export function Ping_eq(a: bigint, b: bigint): boolean {
23367 if(!isWasmInitialized) {
23368 throw new Error("initializeWasm() must be awaited first!");
23370 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
23371 return nativeResponseValue;
23373 // void Pong_free(struct LDKPong this_obj);
23375 export function Pong_free(this_obj: bigint): void {
23376 if(!isWasmInitialized) {
23377 throw new Error("initializeWasm() must be awaited first!");
23379 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
23380 // debug statements here
23382 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
23384 export function Pong_get_byteslen(this_ptr: bigint): number {
23385 if(!isWasmInitialized) {
23386 throw new Error("initializeWasm() must be awaited first!");
23388 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
23389 return nativeResponseValue;
23391 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
23393 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
23394 if(!isWasmInitialized) {
23395 throw new Error("initializeWasm() must be awaited first!");
23397 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
23398 // debug statements here
23400 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
23402 export function Pong_new(byteslen_arg: number): bigint {
23403 if(!isWasmInitialized) {
23404 throw new Error("initializeWasm() must be awaited first!");
23406 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
23407 return nativeResponseValue;
23409 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
23411 export function Pong_clone_ptr(arg: bigint): bigint {
23412 if(!isWasmInitialized) {
23413 throw new Error("initializeWasm() must be awaited first!");
23415 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
23416 return nativeResponseValue;
23418 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
23420 export function Pong_clone(orig: bigint): bigint {
23421 if(!isWasmInitialized) {
23422 throw new Error("initializeWasm() must be awaited first!");
23424 const nativeResponseValue = wasm.TS_Pong_clone(orig);
23425 return nativeResponseValue;
23427 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
23429 export function Pong_eq(a: bigint, b: bigint): boolean {
23430 if(!isWasmInitialized) {
23431 throw new Error("initializeWasm() must be awaited first!");
23433 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
23434 return nativeResponseValue;
23436 // void OpenChannel_free(struct LDKOpenChannel this_obj);
23438 export function OpenChannel_free(this_obj: bigint): void {
23439 if(!isWasmInitialized) {
23440 throw new Error("initializeWasm() must be awaited first!");
23442 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
23443 // debug statements here
23445 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
23447 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
23448 if(!isWasmInitialized) {
23449 throw new Error("initializeWasm() must be awaited first!");
23451 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
23452 return nativeResponseValue;
23454 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23456 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
23457 if(!isWasmInitialized) {
23458 throw new Error("initializeWasm() must be awaited first!");
23460 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
23461 // debug statements here
23463 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
23465 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
23466 if(!isWasmInitialized) {
23467 throw new Error("initializeWasm() must be awaited first!");
23469 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
23470 return nativeResponseValue;
23472 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23474 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
23475 if(!isWasmInitialized) {
23476 throw new Error("initializeWasm() must be awaited first!");
23478 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
23479 // debug statements here
23481 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23483 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
23484 if(!isWasmInitialized) {
23485 throw new Error("initializeWasm() must be awaited first!");
23487 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
23488 return nativeResponseValue;
23490 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23492 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
23493 if(!isWasmInitialized) {
23494 throw new Error("initializeWasm() must be awaited first!");
23496 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
23497 // debug statements here
23499 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23501 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
23502 if(!isWasmInitialized) {
23503 throw new Error("initializeWasm() must be awaited first!");
23505 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
23506 return nativeResponseValue;
23508 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23510 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
23511 if(!isWasmInitialized) {
23512 throw new Error("initializeWasm() must be awaited first!");
23514 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
23515 // debug statements here
23517 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23519 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
23520 if(!isWasmInitialized) {
23521 throw new Error("initializeWasm() must be awaited first!");
23523 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
23524 return nativeResponseValue;
23526 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23528 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
23529 if(!isWasmInitialized) {
23530 throw new Error("initializeWasm() must be awaited first!");
23532 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
23533 // debug statements here
23535 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23537 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
23538 if(!isWasmInitialized) {
23539 throw new Error("initializeWasm() must be awaited first!");
23541 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
23542 return nativeResponseValue;
23544 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23546 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
23547 if(!isWasmInitialized) {
23548 throw new Error("initializeWasm() must be awaited first!");
23550 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
23551 // debug statements here
23553 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23555 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
23556 if(!isWasmInitialized) {
23557 throw new Error("initializeWasm() must be awaited first!");
23559 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
23560 return nativeResponseValue;
23562 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23564 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
23565 if(!isWasmInitialized) {
23566 throw new Error("initializeWasm() must be awaited first!");
23568 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
23569 // debug statements here
23571 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23573 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
23574 if(!isWasmInitialized) {
23575 throw new Error("initializeWasm() must be awaited first!");
23577 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
23578 return nativeResponseValue;
23580 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
23582 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23583 if(!isWasmInitialized) {
23584 throw new Error("initializeWasm() must be awaited first!");
23586 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
23587 // debug statements here
23589 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23591 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
23592 if(!isWasmInitialized) {
23593 throw new Error("initializeWasm() must be awaited first!");
23595 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
23596 return nativeResponseValue;
23598 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
23600 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
23601 if(!isWasmInitialized) {
23602 throw new Error("initializeWasm() must be awaited first!");
23604 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
23605 // debug statements here
23607 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23609 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
23610 if(!isWasmInitialized) {
23611 throw new Error("initializeWasm() must be awaited first!");
23613 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
23614 return nativeResponseValue;
23616 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
23618 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
23619 if(!isWasmInitialized) {
23620 throw new Error("initializeWasm() must be awaited first!");
23622 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
23623 // debug statements here
23625 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23627 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
23628 if(!isWasmInitialized) {
23629 throw new Error("initializeWasm() must be awaited first!");
23631 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
23632 return nativeResponseValue;
23634 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
23636 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
23637 if(!isWasmInitialized) {
23638 throw new Error("initializeWasm() must be awaited first!");
23640 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
23641 // debug statements here
23643 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23645 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
23646 if(!isWasmInitialized) {
23647 throw new Error("initializeWasm() must be awaited first!");
23649 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
23650 return nativeResponseValue;
23652 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23654 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
23655 if(!isWasmInitialized) {
23656 throw new Error("initializeWasm() must be awaited first!");
23658 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
23659 // debug statements here
23661 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23663 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
23664 if(!isWasmInitialized) {
23665 throw new Error("initializeWasm() must be awaited first!");
23667 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
23668 return nativeResponseValue;
23670 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23672 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
23673 if(!isWasmInitialized) {
23674 throw new Error("initializeWasm() must be awaited first!");
23676 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
23677 // debug statements here
23679 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23681 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
23682 if(!isWasmInitialized) {
23683 throw new Error("initializeWasm() must be awaited first!");
23685 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
23686 return nativeResponseValue;
23688 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23690 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
23691 if(!isWasmInitialized) {
23692 throw new Error("initializeWasm() must be awaited first!");
23694 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
23695 // debug statements here
23697 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23699 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
23700 if(!isWasmInitialized) {
23701 throw new Error("initializeWasm() must be awaited first!");
23703 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
23704 return nativeResponseValue;
23706 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23708 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
23709 if(!isWasmInitialized) {
23710 throw new Error("initializeWasm() must be awaited first!");
23712 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
23713 // debug statements here
23715 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23717 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
23718 if(!isWasmInitialized) {
23719 throw new Error("initializeWasm() must be awaited first!");
23721 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
23722 return nativeResponseValue;
23724 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23726 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
23727 if(!isWasmInitialized) {
23728 throw new Error("initializeWasm() must be awaited first!");
23730 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
23731 // debug statements here
23733 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23735 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
23736 if(!isWasmInitialized) {
23737 throw new Error("initializeWasm() must be awaited first!");
23739 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
23740 return nativeResponseValue;
23742 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23744 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
23745 if(!isWasmInitialized) {
23746 throw new Error("initializeWasm() must be awaited first!");
23748 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
23749 // debug statements here
23751 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23753 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
23754 if(!isWasmInitialized) {
23755 throw new Error("initializeWasm() must be awaited first!");
23757 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
23758 return nativeResponseValue;
23760 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
23762 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
23763 if(!isWasmInitialized) {
23764 throw new Error("initializeWasm() must be awaited first!");
23766 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
23767 // debug statements here
23769 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
23771 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
23772 if(!isWasmInitialized) {
23773 throw new Error("initializeWasm() must be awaited first!");
23775 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
23776 return nativeResponseValue;
23778 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
23780 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
23781 if(!isWasmInitialized) {
23782 throw new Error("initializeWasm() must be awaited first!");
23784 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
23785 // debug statements here
23787 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
23789 export function OpenChannel_clone_ptr(arg: bigint): bigint {
23790 if(!isWasmInitialized) {
23791 throw new Error("initializeWasm() must be awaited first!");
23793 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
23794 return nativeResponseValue;
23796 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
23798 export function OpenChannel_clone(orig: bigint): bigint {
23799 if(!isWasmInitialized) {
23800 throw new Error("initializeWasm() must be awaited first!");
23802 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
23803 return nativeResponseValue;
23805 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
23807 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
23808 if(!isWasmInitialized) {
23809 throw new Error("initializeWasm() must be awaited first!");
23811 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
23812 return nativeResponseValue;
23814 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
23816 export function AcceptChannel_free(this_obj: bigint): void {
23817 if(!isWasmInitialized) {
23818 throw new Error("initializeWasm() must be awaited first!");
23820 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
23821 // debug statements here
23823 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
23825 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
23826 if(!isWasmInitialized) {
23827 throw new Error("initializeWasm() must be awaited first!");
23829 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
23830 return nativeResponseValue;
23832 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23834 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
23835 if(!isWasmInitialized) {
23836 throw new Error("initializeWasm() must be awaited first!");
23838 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
23839 // debug statements here
23841 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23843 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
23844 if(!isWasmInitialized) {
23845 throw new Error("initializeWasm() must be awaited first!");
23847 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
23848 return nativeResponseValue;
23850 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23852 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
23853 if(!isWasmInitialized) {
23854 throw new Error("initializeWasm() must be awaited first!");
23856 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
23857 // debug statements here
23859 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23861 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
23862 if(!isWasmInitialized) {
23863 throw new Error("initializeWasm() must be awaited first!");
23865 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
23866 return nativeResponseValue;
23868 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23870 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
23871 if(!isWasmInitialized) {
23872 throw new Error("initializeWasm() must be awaited first!");
23874 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
23875 // debug statements here
23877 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23879 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
23880 if(!isWasmInitialized) {
23881 throw new Error("initializeWasm() must be awaited first!");
23883 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
23884 return nativeResponseValue;
23886 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23888 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
23889 if(!isWasmInitialized) {
23890 throw new Error("initializeWasm() must be awaited first!");
23892 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
23893 // debug statements here
23895 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23897 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
23898 if(!isWasmInitialized) {
23899 throw new Error("initializeWasm() must be awaited first!");
23901 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
23902 return nativeResponseValue;
23904 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
23906 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23907 if(!isWasmInitialized) {
23908 throw new Error("initializeWasm() must be awaited first!");
23910 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
23911 // debug statements here
23913 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23915 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
23916 if(!isWasmInitialized) {
23917 throw new Error("initializeWasm() must be awaited first!");
23919 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
23920 return nativeResponseValue;
23922 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
23924 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
23925 if(!isWasmInitialized) {
23926 throw new Error("initializeWasm() must be awaited first!");
23928 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
23929 // debug statements here
23931 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23933 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
23934 if(!isWasmInitialized) {
23935 throw new Error("initializeWasm() must be awaited first!");
23937 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
23938 return nativeResponseValue;
23940 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
23942 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
23943 if(!isWasmInitialized) {
23944 throw new Error("initializeWasm() must be awaited first!");
23946 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
23947 // debug statements here
23949 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23951 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
23952 if(!isWasmInitialized) {
23953 throw new Error("initializeWasm() must be awaited first!");
23955 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
23956 return nativeResponseValue;
23958 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
23960 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
23961 if(!isWasmInitialized) {
23962 throw new Error("initializeWasm() must be awaited first!");
23964 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
23965 // debug statements here
23967 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23969 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
23970 if(!isWasmInitialized) {
23971 throw new Error("initializeWasm() must be awaited first!");
23973 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
23974 return nativeResponseValue;
23976 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23978 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
23979 if(!isWasmInitialized) {
23980 throw new Error("initializeWasm() must be awaited first!");
23982 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
23983 // debug statements here
23985 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
23987 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
23988 if(!isWasmInitialized) {
23989 throw new Error("initializeWasm() must be awaited first!");
23991 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
23992 return nativeResponseValue;
23994 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23996 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
23997 if(!isWasmInitialized) {
23998 throw new Error("initializeWasm() must be awaited first!");
24000 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
24001 // debug statements here
24003 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24005 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
24006 if(!isWasmInitialized) {
24007 throw new Error("initializeWasm() must be awaited first!");
24009 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
24010 return nativeResponseValue;
24012 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24014 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
24015 if(!isWasmInitialized) {
24016 throw new Error("initializeWasm() must be awaited first!");
24018 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
24019 // debug statements here
24021 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24023 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
24024 if(!isWasmInitialized) {
24025 throw new Error("initializeWasm() must be awaited first!");
24027 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
24028 return nativeResponseValue;
24030 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24032 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
24033 if(!isWasmInitialized) {
24034 throw new Error("initializeWasm() must be awaited first!");
24036 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
24037 // debug statements here
24039 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24041 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
24042 if(!isWasmInitialized) {
24043 throw new Error("initializeWasm() must be awaited first!");
24045 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
24046 return nativeResponseValue;
24048 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24050 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
24051 if(!isWasmInitialized) {
24052 throw new Error("initializeWasm() must be awaited first!");
24054 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
24055 // debug statements here
24057 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24059 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
24060 if(!isWasmInitialized) {
24061 throw new Error("initializeWasm() must be awaited first!");
24063 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
24064 return nativeResponseValue;
24066 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24068 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
24069 if(!isWasmInitialized) {
24070 throw new Error("initializeWasm() must be awaited first!");
24072 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
24073 // debug statements here
24075 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
24077 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
24078 if(!isWasmInitialized) {
24079 throw new Error("initializeWasm() must be awaited first!");
24081 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
24082 return nativeResponseValue;
24084 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
24086 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
24087 if(!isWasmInitialized) {
24088 throw new Error("initializeWasm() must be awaited first!");
24090 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
24091 // debug statements here
24093 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
24095 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
24096 if(!isWasmInitialized) {
24097 throw new Error("initializeWasm() must be awaited first!");
24099 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
24100 return nativeResponseValue;
24102 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
24104 export function AcceptChannel_clone(orig: bigint): bigint {
24105 if(!isWasmInitialized) {
24106 throw new Error("initializeWasm() must be awaited first!");
24108 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
24109 return nativeResponseValue;
24111 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
24113 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
24114 if(!isWasmInitialized) {
24115 throw new Error("initializeWasm() must be awaited first!");
24117 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
24118 return nativeResponseValue;
24120 // void FundingCreated_free(struct LDKFundingCreated this_obj);
24122 export function FundingCreated_free(this_obj: bigint): void {
24123 if(!isWasmInitialized) {
24124 throw new Error("initializeWasm() must be awaited first!");
24126 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
24127 // debug statements here
24129 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
24131 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
24132 if(!isWasmInitialized) {
24133 throw new Error("initializeWasm() must be awaited first!");
24135 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
24136 return nativeResponseValue;
24138 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24140 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
24141 if(!isWasmInitialized) {
24142 throw new Error("initializeWasm() must be awaited first!");
24144 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
24145 // debug statements here
24147 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
24149 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
24150 if(!isWasmInitialized) {
24151 throw new Error("initializeWasm() must be awaited first!");
24153 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
24154 return nativeResponseValue;
24156 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24158 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
24159 if(!isWasmInitialized) {
24160 throw new Error("initializeWasm() must be awaited first!");
24162 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
24163 // debug statements here
24165 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
24167 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
24168 if(!isWasmInitialized) {
24169 throw new Error("initializeWasm() must be awaited first!");
24171 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
24172 return nativeResponseValue;
24174 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
24176 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
24177 if(!isWasmInitialized) {
24178 throw new Error("initializeWasm() must be awaited first!");
24180 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
24181 // debug statements here
24183 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
24185 export function FundingCreated_get_signature(this_ptr: bigint): number {
24186 if(!isWasmInitialized) {
24187 throw new Error("initializeWasm() must be awaited first!");
24189 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
24190 return nativeResponseValue;
24192 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
24194 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
24195 if(!isWasmInitialized) {
24196 throw new Error("initializeWasm() must be awaited first!");
24198 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
24199 // debug statements here
24201 // 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);
24203 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
24204 if(!isWasmInitialized) {
24205 throw new Error("initializeWasm() must be awaited first!");
24207 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
24208 return nativeResponseValue;
24210 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
24212 export function FundingCreated_clone_ptr(arg: bigint): bigint {
24213 if(!isWasmInitialized) {
24214 throw new Error("initializeWasm() must be awaited first!");
24216 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
24217 return nativeResponseValue;
24219 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
24221 export function FundingCreated_clone(orig: bigint): bigint {
24222 if(!isWasmInitialized) {
24223 throw new Error("initializeWasm() must be awaited first!");
24225 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
24226 return nativeResponseValue;
24228 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
24230 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
24231 if(!isWasmInitialized) {
24232 throw new Error("initializeWasm() must be awaited first!");
24234 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
24235 return nativeResponseValue;
24237 // void FundingSigned_free(struct LDKFundingSigned this_obj);
24239 export function FundingSigned_free(this_obj: bigint): void {
24240 if(!isWasmInitialized) {
24241 throw new Error("initializeWasm() must be awaited first!");
24243 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
24244 // debug statements here
24246 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
24248 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
24249 if(!isWasmInitialized) {
24250 throw new Error("initializeWasm() must be awaited first!");
24252 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
24253 return nativeResponseValue;
24255 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24257 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
24258 if(!isWasmInitialized) {
24259 throw new Error("initializeWasm() must be awaited first!");
24261 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
24262 // debug statements here
24264 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
24266 export function FundingSigned_get_signature(this_ptr: bigint): number {
24267 if(!isWasmInitialized) {
24268 throw new Error("initializeWasm() must be awaited first!");
24270 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
24271 return nativeResponseValue;
24273 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
24275 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
24276 if(!isWasmInitialized) {
24277 throw new Error("initializeWasm() must be awaited first!");
24279 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
24280 // debug statements here
24282 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
24284 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
24285 if(!isWasmInitialized) {
24286 throw new Error("initializeWasm() must be awaited first!");
24288 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
24289 return nativeResponseValue;
24291 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
24293 export function FundingSigned_clone_ptr(arg: bigint): bigint {
24294 if(!isWasmInitialized) {
24295 throw new Error("initializeWasm() must be awaited first!");
24297 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
24298 return nativeResponseValue;
24300 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
24302 export function FundingSigned_clone(orig: bigint): bigint {
24303 if(!isWasmInitialized) {
24304 throw new Error("initializeWasm() must be awaited first!");
24306 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
24307 return nativeResponseValue;
24309 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
24311 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
24312 if(!isWasmInitialized) {
24313 throw new Error("initializeWasm() must be awaited first!");
24315 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
24316 return nativeResponseValue;
24318 // void ChannelReady_free(struct LDKChannelReady this_obj);
24320 export function ChannelReady_free(this_obj: bigint): void {
24321 if(!isWasmInitialized) {
24322 throw new Error("initializeWasm() must be awaited first!");
24324 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
24325 // debug statements here
24327 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
24329 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
24330 if(!isWasmInitialized) {
24331 throw new Error("initializeWasm() must be awaited first!");
24333 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
24334 return nativeResponseValue;
24336 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24338 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
24339 if(!isWasmInitialized) {
24340 throw new Error("initializeWasm() must be awaited first!");
24342 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
24343 // debug statements here
24345 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
24347 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
24348 if(!isWasmInitialized) {
24349 throw new Error("initializeWasm() must be awaited first!");
24351 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
24352 return nativeResponseValue;
24354 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24356 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
24357 if(!isWasmInitialized) {
24358 throw new Error("initializeWasm() must be awaited first!");
24360 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
24361 // debug statements here
24363 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
24365 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
24366 if(!isWasmInitialized) {
24367 throw new Error("initializeWasm() must be awaited first!");
24369 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
24370 return nativeResponseValue;
24372 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
24374 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
24375 if(!isWasmInitialized) {
24376 throw new Error("initializeWasm() must be awaited first!");
24378 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
24379 // debug statements here
24381 // 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);
24383 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
24384 if(!isWasmInitialized) {
24385 throw new Error("initializeWasm() must be awaited first!");
24387 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
24388 return nativeResponseValue;
24390 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
24392 export function ChannelReady_clone_ptr(arg: bigint): bigint {
24393 if(!isWasmInitialized) {
24394 throw new Error("initializeWasm() must be awaited first!");
24396 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
24397 return nativeResponseValue;
24399 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
24401 export function ChannelReady_clone(orig: bigint): bigint {
24402 if(!isWasmInitialized) {
24403 throw new Error("initializeWasm() must be awaited first!");
24405 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
24406 return nativeResponseValue;
24408 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
24410 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
24411 if(!isWasmInitialized) {
24412 throw new Error("initializeWasm() must be awaited first!");
24414 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
24415 return nativeResponseValue;
24417 // void Shutdown_free(struct LDKShutdown this_obj);
24419 export function Shutdown_free(this_obj: bigint): void {
24420 if(!isWasmInitialized) {
24421 throw new Error("initializeWasm() must be awaited first!");
24423 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
24424 // debug statements here
24426 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
24428 export function Shutdown_get_channel_id(this_ptr: bigint): number {
24429 if(!isWasmInitialized) {
24430 throw new Error("initializeWasm() must be awaited first!");
24432 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
24433 return nativeResponseValue;
24435 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24437 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
24438 if(!isWasmInitialized) {
24439 throw new Error("initializeWasm() must be awaited first!");
24441 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
24442 // debug statements here
24444 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
24446 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
24447 if(!isWasmInitialized) {
24448 throw new Error("initializeWasm() must be awaited first!");
24450 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
24451 return nativeResponseValue;
24453 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
24455 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
24456 if(!isWasmInitialized) {
24457 throw new Error("initializeWasm() must be awaited first!");
24459 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
24460 // debug statements here
24462 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
24464 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
24465 if(!isWasmInitialized) {
24466 throw new Error("initializeWasm() must be awaited first!");
24468 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
24469 return nativeResponseValue;
24471 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
24473 export function Shutdown_clone_ptr(arg: bigint): bigint {
24474 if(!isWasmInitialized) {
24475 throw new Error("initializeWasm() must be awaited first!");
24477 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
24478 return nativeResponseValue;
24480 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
24482 export function Shutdown_clone(orig: bigint): bigint {
24483 if(!isWasmInitialized) {
24484 throw new Error("initializeWasm() must be awaited first!");
24486 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
24487 return nativeResponseValue;
24489 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
24491 export function Shutdown_eq(a: bigint, b: bigint): boolean {
24492 if(!isWasmInitialized) {
24493 throw new Error("initializeWasm() must be awaited first!");
24495 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
24496 return nativeResponseValue;
24498 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
24500 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
24501 if(!isWasmInitialized) {
24502 throw new Error("initializeWasm() must be awaited first!");
24504 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
24505 // debug statements here
24507 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
24509 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
24510 if(!isWasmInitialized) {
24511 throw new Error("initializeWasm() must be awaited first!");
24513 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
24514 return nativeResponseValue;
24516 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
24518 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
24519 if(!isWasmInitialized) {
24520 throw new Error("initializeWasm() must be awaited first!");
24522 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
24523 // debug statements here
24525 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
24527 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
24528 if(!isWasmInitialized) {
24529 throw new Error("initializeWasm() must be awaited first!");
24531 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
24532 return nativeResponseValue;
24534 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
24536 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
24537 if(!isWasmInitialized) {
24538 throw new Error("initializeWasm() must be awaited first!");
24540 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
24541 // debug statements here
24543 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
24545 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
24546 if(!isWasmInitialized) {
24547 throw new Error("initializeWasm() must be awaited first!");
24549 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
24550 return nativeResponseValue;
24552 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
24554 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
24555 if(!isWasmInitialized) {
24556 throw new Error("initializeWasm() must be awaited first!");
24558 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
24559 return nativeResponseValue;
24561 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
24563 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
24564 if(!isWasmInitialized) {
24565 throw new Error("initializeWasm() must be awaited first!");
24567 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
24568 return nativeResponseValue;
24570 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
24572 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
24573 if(!isWasmInitialized) {
24574 throw new Error("initializeWasm() must be awaited first!");
24576 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
24577 return nativeResponseValue;
24579 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
24581 export function ClosingSigned_free(this_obj: bigint): void {
24582 if(!isWasmInitialized) {
24583 throw new Error("initializeWasm() must be awaited first!");
24585 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
24586 // debug statements here
24588 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
24590 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
24591 if(!isWasmInitialized) {
24592 throw new Error("initializeWasm() must be awaited first!");
24594 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
24595 return nativeResponseValue;
24597 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24599 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
24600 if(!isWasmInitialized) {
24601 throw new Error("initializeWasm() must be awaited first!");
24603 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
24604 // debug statements here
24606 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
24608 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
24609 if(!isWasmInitialized) {
24610 throw new Error("initializeWasm() must be awaited first!");
24612 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
24613 return nativeResponseValue;
24615 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
24617 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
24618 if(!isWasmInitialized) {
24619 throw new Error("initializeWasm() must be awaited first!");
24621 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
24622 // debug statements here
24624 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
24626 export function ClosingSigned_get_signature(this_ptr: bigint): number {
24627 if(!isWasmInitialized) {
24628 throw new Error("initializeWasm() must be awaited first!");
24630 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
24631 return nativeResponseValue;
24633 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
24635 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
24636 if(!isWasmInitialized) {
24637 throw new Error("initializeWasm() must be awaited first!");
24639 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
24640 // debug statements here
24642 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
24644 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
24645 if(!isWasmInitialized) {
24646 throw new Error("initializeWasm() must be awaited first!");
24648 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
24649 return nativeResponseValue;
24651 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
24653 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
24654 if(!isWasmInitialized) {
24655 throw new Error("initializeWasm() must be awaited first!");
24657 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
24658 // debug statements here
24660 // 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);
24662 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
24663 if(!isWasmInitialized) {
24664 throw new Error("initializeWasm() must be awaited first!");
24666 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
24667 return nativeResponseValue;
24669 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
24671 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
24672 if(!isWasmInitialized) {
24673 throw new Error("initializeWasm() must be awaited first!");
24675 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
24676 return nativeResponseValue;
24678 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
24680 export function ClosingSigned_clone(orig: bigint): bigint {
24681 if(!isWasmInitialized) {
24682 throw new Error("initializeWasm() must be awaited first!");
24684 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
24685 return nativeResponseValue;
24687 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
24689 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
24690 if(!isWasmInitialized) {
24691 throw new Error("initializeWasm() must be awaited first!");
24693 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
24694 return nativeResponseValue;
24696 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
24698 export function UpdateAddHTLC_free(this_obj: bigint): void {
24699 if(!isWasmInitialized) {
24700 throw new Error("initializeWasm() must be awaited first!");
24702 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
24703 // debug statements here
24705 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
24707 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
24708 if(!isWasmInitialized) {
24709 throw new Error("initializeWasm() must be awaited first!");
24711 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
24712 return nativeResponseValue;
24714 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24716 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24717 if(!isWasmInitialized) {
24718 throw new Error("initializeWasm() must be awaited first!");
24720 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
24721 // debug statements here
24723 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
24725 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
24726 if(!isWasmInitialized) {
24727 throw new Error("initializeWasm() must be awaited first!");
24729 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
24730 return nativeResponseValue;
24732 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
24734 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
24735 if(!isWasmInitialized) {
24736 throw new Error("initializeWasm() must be awaited first!");
24738 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
24739 // debug statements here
24741 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
24743 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
24744 if(!isWasmInitialized) {
24745 throw new Error("initializeWasm() must be awaited first!");
24747 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
24748 return nativeResponseValue;
24750 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
24752 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
24753 if(!isWasmInitialized) {
24754 throw new Error("initializeWasm() must be awaited first!");
24756 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
24757 // debug statements here
24759 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
24761 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
24762 if(!isWasmInitialized) {
24763 throw new Error("initializeWasm() must be awaited first!");
24765 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
24766 return nativeResponseValue;
24768 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24770 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
24771 if(!isWasmInitialized) {
24772 throw new Error("initializeWasm() must be awaited first!");
24774 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
24775 // debug statements here
24777 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
24779 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
24780 if(!isWasmInitialized) {
24781 throw new Error("initializeWasm() must be awaited first!");
24783 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
24784 return nativeResponseValue;
24786 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
24788 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
24789 if(!isWasmInitialized) {
24790 throw new Error("initializeWasm() must be awaited first!");
24792 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
24793 // debug statements here
24795 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
24797 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
24798 if(!isWasmInitialized) {
24799 throw new Error("initializeWasm() must be awaited first!");
24801 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
24802 return nativeResponseValue;
24804 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
24806 export function UpdateAddHTLC_clone(orig: bigint): bigint {
24807 if(!isWasmInitialized) {
24808 throw new Error("initializeWasm() must be awaited first!");
24810 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
24811 return nativeResponseValue;
24813 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
24815 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
24816 if(!isWasmInitialized) {
24817 throw new Error("initializeWasm() must be awaited first!");
24819 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
24820 return nativeResponseValue;
24822 // void OnionMessage_free(struct LDKOnionMessage this_obj);
24824 export function OnionMessage_free(this_obj: bigint): void {
24825 if(!isWasmInitialized) {
24826 throw new Error("initializeWasm() must be awaited first!");
24828 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
24829 // debug statements here
24831 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
24833 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
24834 if(!isWasmInitialized) {
24835 throw new Error("initializeWasm() must be awaited first!");
24837 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
24838 return nativeResponseValue;
24840 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24842 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
24843 if(!isWasmInitialized) {
24844 throw new Error("initializeWasm() must be awaited first!");
24846 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
24847 // debug statements here
24849 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
24851 export function OnionMessage_clone_ptr(arg: bigint): bigint {
24852 if(!isWasmInitialized) {
24853 throw new Error("initializeWasm() must be awaited first!");
24855 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
24856 return nativeResponseValue;
24858 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
24860 export function OnionMessage_clone(orig: bigint): bigint {
24861 if(!isWasmInitialized) {
24862 throw new Error("initializeWasm() must be awaited first!");
24864 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
24865 return nativeResponseValue;
24867 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
24869 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
24870 if(!isWasmInitialized) {
24871 throw new Error("initializeWasm() must be awaited first!");
24873 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
24874 return nativeResponseValue;
24876 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
24878 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
24879 if(!isWasmInitialized) {
24880 throw new Error("initializeWasm() must be awaited first!");
24882 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
24883 // debug statements here
24885 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
24887 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
24888 if(!isWasmInitialized) {
24889 throw new Error("initializeWasm() must be awaited first!");
24891 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
24892 return nativeResponseValue;
24894 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24896 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24897 if(!isWasmInitialized) {
24898 throw new Error("initializeWasm() must be awaited first!");
24900 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
24901 // debug statements here
24903 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
24905 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
24906 if(!isWasmInitialized) {
24907 throw new Error("initializeWasm() must be awaited first!");
24909 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
24910 return nativeResponseValue;
24912 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
24914 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
24915 if(!isWasmInitialized) {
24916 throw new Error("initializeWasm() must be awaited first!");
24918 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
24919 // debug statements here
24921 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
24923 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
24924 if(!isWasmInitialized) {
24925 throw new Error("initializeWasm() must be awaited first!");
24927 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
24928 return nativeResponseValue;
24930 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24932 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
24933 if(!isWasmInitialized) {
24934 throw new Error("initializeWasm() must be awaited first!");
24936 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
24937 // debug statements here
24939 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
24941 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
24942 if(!isWasmInitialized) {
24943 throw new Error("initializeWasm() must be awaited first!");
24945 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
24946 return nativeResponseValue;
24948 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
24950 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
24951 if(!isWasmInitialized) {
24952 throw new Error("initializeWasm() must be awaited first!");
24954 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
24955 return nativeResponseValue;
24957 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
24959 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
24960 if(!isWasmInitialized) {
24961 throw new Error("initializeWasm() must be awaited first!");
24963 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
24964 return nativeResponseValue;
24966 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
24968 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
24969 if(!isWasmInitialized) {
24970 throw new Error("initializeWasm() must be awaited first!");
24972 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
24973 return nativeResponseValue;
24975 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
24977 export function UpdateFailHTLC_free(this_obj: bigint): void {
24978 if(!isWasmInitialized) {
24979 throw new Error("initializeWasm() must be awaited first!");
24981 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
24982 // debug statements here
24984 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
24986 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
24987 if(!isWasmInitialized) {
24988 throw new Error("initializeWasm() must be awaited first!");
24990 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
24991 return nativeResponseValue;
24993 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24995 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
24996 if(!isWasmInitialized) {
24997 throw new Error("initializeWasm() must be awaited first!");
24999 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
25000 // debug statements here
25002 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
25004 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
25005 if(!isWasmInitialized) {
25006 throw new Error("initializeWasm() must be awaited first!");
25008 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
25009 return nativeResponseValue;
25011 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
25013 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25014 if(!isWasmInitialized) {
25015 throw new Error("initializeWasm() must be awaited first!");
25017 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
25018 // debug statements here
25020 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
25022 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
25023 if(!isWasmInitialized) {
25024 throw new Error("initializeWasm() must be awaited first!");
25026 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
25027 return nativeResponseValue;
25029 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
25031 export function UpdateFailHTLC_clone(orig: bigint): bigint {
25032 if(!isWasmInitialized) {
25033 throw new Error("initializeWasm() must be awaited first!");
25035 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
25036 return nativeResponseValue;
25038 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
25040 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
25041 if(!isWasmInitialized) {
25042 throw new Error("initializeWasm() must be awaited first!");
25044 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
25045 return nativeResponseValue;
25047 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
25049 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
25050 if(!isWasmInitialized) {
25051 throw new Error("initializeWasm() must be awaited first!");
25053 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
25054 // debug statements here
25056 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
25058 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
25059 if(!isWasmInitialized) {
25060 throw new Error("initializeWasm() must be awaited first!");
25062 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
25063 return nativeResponseValue;
25065 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25067 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
25068 if(!isWasmInitialized) {
25069 throw new Error("initializeWasm() must be awaited first!");
25071 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
25072 // debug statements here
25074 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
25076 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
25077 if(!isWasmInitialized) {
25078 throw new Error("initializeWasm() must be awaited first!");
25080 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
25081 return nativeResponseValue;
25083 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
25085 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
25086 if(!isWasmInitialized) {
25087 throw new Error("initializeWasm() must be awaited first!");
25089 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
25090 // debug statements here
25092 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
25094 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
25095 if(!isWasmInitialized) {
25096 throw new Error("initializeWasm() must be awaited first!");
25098 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
25099 return nativeResponseValue;
25101 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
25103 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
25104 if(!isWasmInitialized) {
25105 throw new Error("initializeWasm() must be awaited first!");
25107 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
25108 // debug statements here
25110 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
25112 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
25113 if(!isWasmInitialized) {
25114 throw new Error("initializeWasm() must be awaited first!");
25116 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
25117 return nativeResponseValue;
25119 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
25121 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
25122 if(!isWasmInitialized) {
25123 throw new Error("initializeWasm() must be awaited first!");
25125 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
25126 return nativeResponseValue;
25128 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
25130 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
25131 if(!isWasmInitialized) {
25132 throw new Error("initializeWasm() must be awaited first!");
25134 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
25135 return nativeResponseValue;
25137 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
25139 export function CommitmentSigned_free(this_obj: bigint): void {
25140 if(!isWasmInitialized) {
25141 throw new Error("initializeWasm() must be awaited first!");
25143 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
25144 // debug statements here
25146 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
25148 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
25149 if(!isWasmInitialized) {
25150 throw new Error("initializeWasm() must be awaited first!");
25152 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
25153 return nativeResponseValue;
25155 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25157 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
25158 if(!isWasmInitialized) {
25159 throw new Error("initializeWasm() must be awaited first!");
25161 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
25162 // debug statements here
25164 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
25166 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
25167 if(!isWasmInitialized) {
25168 throw new Error("initializeWasm() must be awaited first!");
25170 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
25171 return nativeResponseValue;
25173 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
25175 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
25176 if(!isWasmInitialized) {
25177 throw new Error("initializeWasm() must be awaited first!");
25179 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
25180 // debug statements here
25182 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
25184 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
25185 if(!isWasmInitialized) {
25186 throw new Error("initializeWasm() must be awaited first!");
25188 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
25189 return nativeResponseValue;
25191 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
25193 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
25194 if(!isWasmInitialized) {
25195 throw new Error("initializeWasm() must be awaited first!");
25197 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
25198 // debug statements here
25200 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
25202 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
25203 if(!isWasmInitialized) {
25204 throw new Error("initializeWasm() must be awaited first!");
25206 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
25207 return nativeResponseValue;
25209 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
25211 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
25212 if(!isWasmInitialized) {
25213 throw new Error("initializeWasm() must be awaited first!");
25215 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
25216 return nativeResponseValue;
25218 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
25220 export function CommitmentSigned_clone(orig: bigint): bigint {
25221 if(!isWasmInitialized) {
25222 throw new Error("initializeWasm() must be awaited first!");
25224 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
25225 return nativeResponseValue;
25227 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
25229 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
25230 if(!isWasmInitialized) {
25231 throw new Error("initializeWasm() must be awaited first!");
25233 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
25234 return nativeResponseValue;
25236 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
25238 export function RevokeAndACK_free(this_obj: bigint): void {
25239 if(!isWasmInitialized) {
25240 throw new Error("initializeWasm() must be awaited first!");
25242 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
25243 // debug statements here
25245 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
25247 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
25248 if(!isWasmInitialized) {
25249 throw new Error("initializeWasm() must be awaited first!");
25251 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
25252 return nativeResponseValue;
25254 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25256 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
25257 if(!isWasmInitialized) {
25258 throw new Error("initializeWasm() must be awaited first!");
25260 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
25261 // debug statements here
25263 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
25265 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
25266 if(!isWasmInitialized) {
25267 throw new Error("initializeWasm() must be awaited first!");
25269 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
25270 return nativeResponseValue;
25272 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25274 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
25275 if(!isWasmInitialized) {
25276 throw new Error("initializeWasm() must be awaited first!");
25278 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
25279 // debug statements here
25281 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
25283 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
25284 if(!isWasmInitialized) {
25285 throw new Error("initializeWasm() must be awaited first!");
25287 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
25288 return nativeResponseValue;
25290 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25292 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
25293 if(!isWasmInitialized) {
25294 throw new Error("initializeWasm() must be awaited first!");
25296 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
25297 // debug statements here
25299 // 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);
25301 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
25302 if(!isWasmInitialized) {
25303 throw new Error("initializeWasm() must be awaited first!");
25305 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
25306 return nativeResponseValue;
25308 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
25310 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
25311 if(!isWasmInitialized) {
25312 throw new Error("initializeWasm() must be awaited first!");
25314 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
25315 return nativeResponseValue;
25317 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
25319 export function RevokeAndACK_clone(orig: bigint): bigint {
25320 if(!isWasmInitialized) {
25321 throw new Error("initializeWasm() must be awaited first!");
25323 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
25324 return nativeResponseValue;
25326 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
25328 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
25329 if(!isWasmInitialized) {
25330 throw new Error("initializeWasm() must be awaited first!");
25332 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
25333 return nativeResponseValue;
25335 // void UpdateFee_free(struct LDKUpdateFee this_obj);
25337 export function UpdateFee_free(this_obj: bigint): void {
25338 if(!isWasmInitialized) {
25339 throw new Error("initializeWasm() must be awaited first!");
25341 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
25342 // debug statements here
25344 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
25346 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
25347 if(!isWasmInitialized) {
25348 throw new Error("initializeWasm() must be awaited first!");
25350 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
25351 return nativeResponseValue;
25353 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25355 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
25356 if(!isWasmInitialized) {
25357 throw new Error("initializeWasm() must be awaited first!");
25359 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
25360 // debug statements here
25362 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
25364 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
25365 if(!isWasmInitialized) {
25366 throw new Error("initializeWasm() must be awaited first!");
25368 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
25369 return nativeResponseValue;
25371 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
25373 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
25374 if(!isWasmInitialized) {
25375 throw new Error("initializeWasm() must be awaited first!");
25377 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
25378 // debug statements here
25380 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
25382 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
25383 if(!isWasmInitialized) {
25384 throw new Error("initializeWasm() must be awaited first!");
25386 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
25387 return nativeResponseValue;
25389 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
25391 export function UpdateFee_clone_ptr(arg: bigint): bigint {
25392 if(!isWasmInitialized) {
25393 throw new Error("initializeWasm() must be awaited first!");
25395 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
25396 return nativeResponseValue;
25398 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
25400 export function UpdateFee_clone(orig: bigint): bigint {
25401 if(!isWasmInitialized) {
25402 throw new Error("initializeWasm() must be awaited first!");
25404 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
25405 return nativeResponseValue;
25407 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
25409 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
25410 if(!isWasmInitialized) {
25411 throw new Error("initializeWasm() must be awaited first!");
25413 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
25414 return nativeResponseValue;
25416 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
25418 export function DataLossProtect_free(this_obj: bigint): void {
25419 if(!isWasmInitialized) {
25420 throw new Error("initializeWasm() must be awaited first!");
25422 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
25423 // debug statements here
25425 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
25427 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: bigint): number {
25428 if(!isWasmInitialized) {
25429 throw new Error("initializeWasm() must be awaited first!");
25431 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
25432 return nativeResponseValue;
25434 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25436 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
25437 if(!isWasmInitialized) {
25438 throw new Error("initializeWasm() must be awaited first!");
25440 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
25441 // debug statements here
25443 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
25445 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: bigint): number {
25446 if(!isWasmInitialized) {
25447 throw new Error("initializeWasm() must be awaited first!");
25449 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
25450 return nativeResponseValue;
25452 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25454 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
25455 if(!isWasmInitialized) {
25456 throw new Error("initializeWasm() must be awaited first!");
25458 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
25459 // debug statements here
25461 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
25463 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): bigint {
25464 if(!isWasmInitialized) {
25465 throw new Error("initializeWasm() must be awaited first!");
25467 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
25468 return nativeResponseValue;
25470 // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
25472 export function DataLossProtect_clone_ptr(arg: bigint): bigint {
25473 if(!isWasmInitialized) {
25474 throw new Error("initializeWasm() must be awaited first!");
25476 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
25477 return nativeResponseValue;
25479 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
25481 export function DataLossProtect_clone(orig: bigint): bigint {
25482 if(!isWasmInitialized) {
25483 throw new Error("initializeWasm() must be awaited first!");
25485 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
25486 return nativeResponseValue;
25488 // bool DataLossProtect_eq(const struct LDKDataLossProtect *NONNULL_PTR a, const struct LDKDataLossProtect *NONNULL_PTR b);
25490 export function DataLossProtect_eq(a: bigint, b: bigint): boolean {
25491 if(!isWasmInitialized) {
25492 throw new Error("initializeWasm() must be awaited first!");
25494 const nativeResponseValue = wasm.TS_DataLossProtect_eq(a, b);
25495 return nativeResponseValue;
25497 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
25499 export function ChannelReestablish_free(this_obj: bigint): void {
25500 if(!isWasmInitialized) {
25501 throw new Error("initializeWasm() must be awaited first!");
25503 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
25504 // debug statements here
25506 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
25508 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
25509 if(!isWasmInitialized) {
25510 throw new Error("initializeWasm() must be awaited first!");
25512 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
25513 return nativeResponseValue;
25515 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25517 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
25518 if(!isWasmInitialized) {
25519 throw new Error("initializeWasm() must be awaited first!");
25521 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
25522 // debug statements here
25524 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
25526 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
25527 if(!isWasmInitialized) {
25528 throw new Error("initializeWasm() must be awaited first!");
25530 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
25531 return nativeResponseValue;
25533 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
25535 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
25536 if(!isWasmInitialized) {
25537 throw new Error("initializeWasm() must be awaited first!");
25539 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
25540 // debug statements here
25542 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
25544 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
25545 if(!isWasmInitialized) {
25546 throw new Error("initializeWasm() must be awaited first!");
25548 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
25549 return nativeResponseValue;
25551 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
25553 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
25554 if(!isWasmInitialized) {
25555 throw new Error("initializeWasm() must be awaited first!");
25557 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
25558 // debug statements here
25560 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
25562 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
25563 if(!isWasmInitialized) {
25564 throw new Error("initializeWasm() must be awaited first!");
25566 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
25567 return nativeResponseValue;
25569 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
25571 export function ChannelReestablish_clone(orig: bigint): bigint {
25572 if(!isWasmInitialized) {
25573 throw new Error("initializeWasm() must be awaited first!");
25575 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
25576 return nativeResponseValue;
25578 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
25580 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
25581 if(!isWasmInitialized) {
25582 throw new Error("initializeWasm() must be awaited first!");
25584 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
25585 return nativeResponseValue;
25587 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
25589 export function AnnouncementSignatures_free(this_obj: bigint): void {
25590 if(!isWasmInitialized) {
25591 throw new Error("initializeWasm() must be awaited first!");
25593 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
25594 // debug statements here
25596 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
25598 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
25599 if(!isWasmInitialized) {
25600 throw new Error("initializeWasm() must be awaited first!");
25602 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
25603 return nativeResponseValue;
25605 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25607 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
25608 if(!isWasmInitialized) {
25609 throw new Error("initializeWasm() must be awaited first!");
25611 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
25612 // debug statements here
25614 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
25616 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
25617 if(!isWasmInitialized) {
25618 throw new Error("initializeWasm() must be awaited first!");
25620 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
25621 return nativeResponseValue;
25623 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
25625 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
25626 if(!isWasmInitialized) {
25627 throw new Error("initializeWasm() must be awaited first!");
25629 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
25630 // debug statements here
25632 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
25634 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
25635 if(!isWasmInitialized) {
25636 throw new Error("initializeWasm() must be awaited first!");
25638 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
25639 return nativeResponseValue;
25641 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
25643 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
25644 if(!isWasmInitialized) {
25645 throw new Error("initializeWasm() must be awaited first!");
25647 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
25648 // debug statements here
25650 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
25652 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
25653 if(!isWasmInitialized) {
25654 throw new Error("initializeWasm() must be awaited first!");
25656 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
25657 return nativeResponseValue;
25659 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
25661 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
25662 if(!isWasmInitialized) {
25663 throw new Error("initializeWasm() must be awaited first!");
25665 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
25666 // debug statements here
25668 // 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);
25670 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
25671 if(!isWasmInitialized) {
25672 throw new Error("initializeWasm() must be awaited first!");
25674 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
25675 return nativeResponseValue;
25677 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
25679 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
25680 if(!isWasmInitialized) {
25681 throw new Error("initializeWasm() must be awaited first!");
25683 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
25684 return nativeResponseValue;
25686 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
25688 export function AnnouncementSignatures_clone(orig: bigint): bigint {
25689 if(!isWasmInitialized) {
25690 throw new Error("initializeWasm() must be awaited first!");
25692 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
25693 return nativeResponseValue;
25695 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
25697 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
25698 if(!isWasmInitialized) {
25699 throw new Error("initializeWasm() must be awaited first!");
25701 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
25702 return nativeResponseValue;
25704 // void NetAddress_free(struct LDKNetAddress this_ptr);
25706 export function NetAddress_free(this_ptr: bigint): void {
25707 if(!isWasmInitialized) {
25708 throw new Error("initializeWasm() must be awaited first!");
25710 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
25711 // debug statements here
25713 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
25715 export function NetAddress_clone_ptr(arg: bigint): bigint {
25716 if(!isWasmInitialized) {
25717 throw new Error("initializeWasm() must be awaited first!");
25719 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
25720 return nativeResponseValue;
25722 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
25724 export function NetAddress_clone(orig: bigint): bigint {
25725 if(!isWasmInitialized) {
25726 throw new Error("initializeWasm() must be awaited first!");
25728 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
25729 return nativeResponseValue;
25731 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
25733 export function NetAddress_ipv4(addr: number, port: number): bigint {
25734 if(!isWasmInitialized) {
25735 throw new Error("initializeWasm() must be awaited first!");
25737 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
25738 return nativeResponseValue;
25740 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
25742 export function NetAddress_ipv6(addr: number, port: number): bigint {
25743 if(!isWasmInitialized) {
25744 throw new Error("initializeWasm() must be awaited first!");
25746 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
25747 return nativeResponseValue;
25749 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
25751 export function NetAddress_onion_v2(a: number): bigint {
25752 if(!isWasmInitialized) {
25753 throw new Error("initializeWasm() must be awaited first!");
25755 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
25756 return nativeResponseValue;
25758 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
25760 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
25761 if(!isWasmInitialized) {
25762 throw new Error("initializeWasm() must be awaited first!");
25764 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
25765 return nativeResponseValue;
25767 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
25769 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
25770 if(!isWasmInitialized) {
25771 throw new Error("initializeWasm() must be awaited first!");
25773 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
25774 return nativeResponseValue;
25776 // bool NetAddress_eq(const struct LDKNetAddress *NONNULL_PTR a, const struct LDKNetAddress *NONNULL_PTR b);
25778 export function NetAddress_eq(a: bigint, b: bigint): boolean {
25779 if(!isWasmInitialized) {
25780 throw new Error("initializeWasm() must be awaited first!");
25782 const nativeResponseValue = wasm.TS_NetAddress_eq(a, b);
25783 return nativeResponseValue;
25785 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
25787 export function NetAddress_write(obj: bigint): number {
25788 if(!isWasmInitialized) {
25789 throw new Error("initializeWasm() must be awaited first!");
25791 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
25792 return nativeResponseValue;
25794 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
25796 export function NetAddress_read(ser: number): bigint {
25797 if(!isWasmInitialized) {
25798 throw new Error("initializeWasm() must be awaited first!");
25800 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
25801 return nativeResponseValue;
25803 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
25805 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
25806 if(!isWasmInitialized) {
25807 throw new Error("initializeWasm() must be awaited first!");
25809 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
25810 // debug statements here
25812 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25814 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
25815 if(!isWasmInitialized) {
25816 throw new Error("initializeWasm() must be awaited first!");
25818 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
25819 return nativeResponseValue;
25821 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
25823 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
25824 if(!isWasmInitialized) {
25825 throw new Error("initializeWasm() must be awaited first!");
25827 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
25828 // debug statements here
25830 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25832 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
25833 if(!isWasmInitialized) {
25834 throw new Error("initializeWasm() must be awaited first!");
25836 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
25837 return nativeResponseValue;
25839 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
25841 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
25842 if(!isWasmInitialized) {
25843 throw new Error("initializeWasm() must be awaited first!");
25845 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
25846 // debug statements here
25848 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25850 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): number {
25851 if(!isWasmInitialized) {
25852 throw new Error("initializeWasm() must be awaited first!");
25854 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
25855 return nativeResponseValue;
25857 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25859 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: number): void {
25860 if(!isWasmInitialized) {
25861 throw new Error("initializeWasm() must be awaited first!");
25863 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
25864 // debug statements here
25866 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
25868 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
25869 if(!isWasmInitialized) {
25870 throw new Error("initializeWasm() must be awaited first!");
25872 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
25873 return nativeResponseValue;
25875 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
25877 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
25878 if(!isWasmInitialized) {
25879 throw new Error("initializeWasm() must be awaited first!");
25881 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
25882 // debug statements here
25884 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
25886 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
25887 if(!isWasmInitialized) {
25888 throw new Error("initializeWasm() must be awaited first!");
25890 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
25891 return nativeResponseValue;
25893 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25895 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
25896 if(!isWasmInitialized) {
25897 throw new Error("initializeWasm() must be awaited first!");
25899 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
25900 // debug statements here
25902 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
25904 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
25905 if(!isWasmInitialized) {
25906 throw new Error("initializeWasm() must be awaited first!");
25908 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
25909 return nativeResponseValue;
25911 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
25913 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
25914 if(!isWasmInitialized) {
25915 throw new Error("initializeWasm() must be awaited first!");
25917 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
25918 // debug statements here
25920 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
25922 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
25923 if(!isWasmInitialized) {
25924 throw new Error("initializeWasm() must be awaited first!");
25926 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
25927 return nativeResponseValue;
25929 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
25931 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
25932 if(!isWasmInitialized) {
25933 throw new Error("initializeWasm() must be awaited first!");
25935 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
25936 return nativeResponseValue;
25938 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
25940 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
25941 if(!isWasmInitialized) {
25942 throw new Error("initializeWasm() must be awaited first!");
25944 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
25945 return nativeResponseValue;
25947 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
25949 export function NodeAnnouncement_free(this_obj: bigint): void {
25950 if(!isWasmInitialized) {
25951 throw new Error("initializeWasm() must be awaited first!");
25953 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
25954 // debug statements here
25956 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
25958 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
25959 if(!isWasmInitialized) {
25960 throw new Error("initializeWasm() must be awaited first!");
25962 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
25963 return nativeResponseValue;
25965 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
25967 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
25968 if(!isWasmInitialized) {
25969 throw new Error("initializeWasm() must be awaited first!");
25971 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
25972 // debug statements here
25974 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
25976 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
25977 if(!isWasmInitialized) {
25978 throw new Error("initializeWasm() must be awaited first!");
25980 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
25981 return nativeResponseValue;
25983 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
25985 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
25986 if(!isWasmInitialized) {
25987 throw new Error("initializeWasm() must be awaited first!");
25989 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
25990 // debug statements here
25992 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
25994 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
25995 if(!isWasmInitialized) {
25996 throw new Error("initializeWasm() must be awaited first!");
25998 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
25999 return nativeResponseValue;
26001 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
26003 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
26004 if(!isWasmInitialized) {
26005 throw new Error("initializeWasm() must be awaited first!");
26007 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
26008 return nativeResponseValue;
26010 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
26012 export function NodeAnnouncement_clone(orig: bigint): bigint {
26013 if(!isWasmInitialized) {
26014 throw new Error("initializeWasm() must be awaited first!");
26016 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
26017 return nativeResponseValue;
26019 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
26021 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
26022 if(!isWasmInitialized) {
26023 throw new Error("initializeWasm() must be awaited first!");
26025 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
26026 return nativeResponseValue;
26028 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
26030 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
26031 if(!isWasmInitialized) {
26032 throw new Error("initializeWasm() must be awaited first!");
26034 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
26035 // debug statements here
26037 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26039 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
26040 if(!isWasmInitialized) {
26041 throw new Error("initializeWasm() must be awaited first!");
26043 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
26044 return nativeResponseValue;
26046 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
26048 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
26049 if(!isWasmInitialized) {
26050 throw new Error("initializeWasm() must be awaited first!");
26052 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
26053 // debug statements here
26055 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
26057 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
26058 if(!isWasmInitialized) {
26059 throw new Error("initializeWasm() must be awaited first!");
26061 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
26062 return nativeResponseValue;
26064 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26066 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
26067 if(!isWasmInitialized) {
26068 throw new Error("initializeWasm() must be awaited first!");
26070 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
26071 // debug statements here
26073 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26075 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
26076 if(!isWasmInitialized) {
26077 throw new Error("initializeWasm() must be awaited first!");
26079 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
26080 return nativeResponseValue;
26082 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
26084 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
26085 if(!isWasmInitialized) {
26086 throw new Error("initializeWasm() must be awaited first!");
26088 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
26089 // debug statements here
26091 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26093 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): number {
26094 if(!isWasmInitialized) {
26095 throw new Error("initializeWasm() must be awaited first!");
26097 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
26098 return nativeResponseValue;
26100 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26102 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: number): void {
26103 if(!isWasmInitialized) {
26104 throw new Error("initializeWasm() must be awaited first!");
26106 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
26107 // debug statements here
26109 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26111 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): number {
26112 if(!isWasmInitialized) {
26113 throw new Error("initializeWasm() must be awaited first!");
26115 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
26116 return nativeResponseValue;
26118 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26120 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: number): void {
26121 if(!isWasmInitialized) {
26122 throw new Error("initializeWasm() must be awaited first!");
26124 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
26125 // debug statements here
26127 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26129 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): number {
26130 if(!isWasmInitialized) {
26131 throw new Error("initializeWasm() must be awaited first!");
26133 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
26134 return nativeResponseValue;
26136 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26138 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: number): void {
26139 if(!isWasmInitialized) {
26140 throw new Error("initializeWasm() must be awaited first!");
26142 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
26143 // debug statements here
26145 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
26147 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): number {
26148 if(!isWasmInitialized) {
26149 throw new Error("initializeWasm() must be awaited first!");
26151 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
26152 return nativeResponseValue;
26154 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26156 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: number): void {
26157 if(!isWasmInitialized) {
26158 throw new Error("initializeWasm() must be awaited first!");
26160 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
26161 // debug statements here
26163 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
26165 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
26166 if(!isWasmInitialized) {
26167 throw new Error("initializeWasm() must be awaited first!");
26169 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
26170 return nativeResponseValue;
26172 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
26174 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
26175 if(!isWasmInitialized) {
26176 throw new Error("initializeWasm() must be awaited first!");
26178 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
26179 return nativeResponseValue;
26181 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
26183 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
26184 if(!isWasmInitialized) {
26185 throw new Error("initializeWasm() must be awaited first!");
26187 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
26188 return nativeResponseValue;
26190 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
26192 export function ChannelAnnouncement_free(this_obj: bigint): void {
26193 if(!isWasmInitialized) {
26194 throw new Error("initializeWasm() must be awaited first!");
26196 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
26197 // debug statements here
26199 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
26201 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
26202 if(!isWasmInitialized) {
26203 throw new Error("initializeWasm() must be awaited first!");
26205 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
26206 return nativeResponseValue;
26208 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
26210 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
26211 if(!isWasmInitialized) {
26212 throw new Error("initializeWasm() must be awaited first!");
26214 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
26215 // debug statements here
26217 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
26219 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
26220 if(!isWasmInitialized) {
26221 throw new Error("initializeWasm() must be awaited first!");
26223 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
26224 return nativeResponseValue;
26226 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
26228 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
26229 if(!isWasmInitialized) {
26230 throw new Error("initializeWasm() must be awaited first!");
26232 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
26233 // debug statements here
26235 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
26237 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
26238 if(!isWasmInitialized) {
26239 throw new Error("initializeWasm() must be awaited first!");
26241 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
26242 return nativeResponseValue;
26244 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
26246 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
26247 if(!isWasmInitialized) {
26248 throw new Error("initializeWasm() must be awaited first!");
26250 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
26251 // debug statements here
26253 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
26255 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
26256 if(!isWasmInitialized) {
26257 throw new Error("initializeWasm() must be awaited first!");
26259 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
26260 return nativeResponseValue;
26262 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
26264 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
26265 if(!isWasmInitialized) {
26266 throw new Error("initializeWasm() must be awaited first!");
26268 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
26269 // debug statements here
26271 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
26273 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
26274 if(!isWasmInitialized) {
26275 throw new Error("initializeWasm() must be awaited first!");
26277 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
26278 return nativeResponseValue;
26280 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
26282 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
26283 if(!isWasmInitialized) {
26284 throw new Error("initializeWasm() must be awaited first!");
26286 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
26287 // debug statements here
26289 // 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);
26291 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: bigint): bigint {
26292 if(!isWasmInitialized) {
26293 throw new Error("initializeWasm() must be awaited first!");
26295 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
26296 return nativeResponseValue;
26298 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
26300 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
26301 if(!isWasmInitialized) {
26302 throw new Error("initializeWasm() must be awaited first!");
26304 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
26305 return nativeResponseValue;
26307 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
26309 export function ChannelAnnouncement_clone(orig: bigint): bigint {
26310 if(!isWasmInitialized) {
26311 throw new Error("initializeWasm() must be awaited first!");
26313 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
26314 return nativeResponseValue;
26316 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
26318 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
26319 if(!isWasmInitialized) {
26320 throw new Error("initializeWasm() must be awaited first!");
26322 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
26323 return nativeResponseValue;
26325 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
26327 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
26328 if(!isWasmInitialized) {
26329 throw new Error("initializeWasm() must be awaited first!");
26331 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
26332 // debug statements here
26334 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
26336 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
26337 if(!isWasmInitialized) {
26338 throw new Error("initializeWasm() must be awaited first!");
26340 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
26341 return nativeResponseValue;
26343 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26345 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
26346 if(!isWasmInitialized) {
26347 throw new Error("initializeWasm() must be awaited first!");
26349 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
26350 // debug statements here
26352 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26354 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
26355 if(!isWasmInitialized) {
26356 throw new Error("initializeWasm() must be awaited first!");
26358 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
26359 return nativeResponseValue;
26361 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
26363 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
26364 if(!isWasmInitialized) {
26365 throw new Error("initializeWasm() must be awaited first!");
26367 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
26368 // debug statements here
26370 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26372 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
26373 if(!isWasmInitialized) {
26374 throw new Error("initializeWasm() must be awaited first!");
26376 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
26377 return nativeResponseValue;
26379 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
26381 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
26382 if(!isWasmInitialized) {
26383 throw new Error("initializeWasm() must be awaited first!");
26385 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
26386 // debug statements here
26388 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26390 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
26391 if(!isWasmInitialized) {
26392 throw new Error("initializeWasm() must be awaited first!");
26394 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
26395 return nativeResponseValue;
26397 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
26399 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
26400 if(!isWasmInitialized) {
26401 throw new Error("initializeWasm() must be awaited first!");
26403 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
26404 // debug statements here
26406 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26408 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
26409 if(!isWasmInitialized) {
26410 throw new Error("initializeWasm() must be awaited first!");
26412 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
26413 return nativeResponseValue;
26415 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
26417 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
26418 if(!isWasmInitialized) {
26419 throw new Error("initializeWasm() must be awaited first!");
26421 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
26422 // debug statements here
26424 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26426 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
26427 if(!isWasmInitialized) {
26428 throw new Error("initializeWasm() must be awaited first!");
26430 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
26431 return nativeResponseValue;
26433 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
26435 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
26436 if(!isWasmInitialized) {
26437 throw new Error("initializeWasm() must be awaited first!");
26439 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
26440 // debug statements here
26442 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26444 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
26445 if(!isWasmInitialized) {
26446 throw new Error("initializeWasm() must be awaited first!");
26448 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
26449 return nativeResponseValue;
26451 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
26453 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
26454 if(!isWasmInitialized) {
26455 throw new Error("initializeWasm() must be awaited first!");
26457 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
26458 // debug statements here
26460 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26462 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
26463 if(!isWasmInitialized) {
26464 throw new Error("initializeWasm() must be awaited first!");
26466 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
26467 return nativeResponseValue;
26469 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
26471 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
26472 if(!isWasmInitialized) {
26473 throw new Error("initializeWasm() must be awaited first!");
26475 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
26476 // debug statements here
26478 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26480 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
26481 if(!isWasmInitialized) {
26482 throw new Error("initializeWasm() must be awaited first!");
26484 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
26485 return nativeResponseValue;
26487 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
26489 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
26490 if(!isWasmInitialized) {
26491 throw new Error("initializeWasm() must be awaited first!");
26493 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
26494 // debug statements here
26496 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
26498 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
26499 if(!isWasmInitialized) {
26500 throw new Error("initializeWasm() must be awaited first!");
26502 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
26503 return nativeResponseValue;
26505 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
26507 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
26508 if(!isWasmInitialized) {
26509 throw new Error("initializeWasm() must be awaited first!");
26511 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
26512 // debug statements here
26514 // MUST_USE_RES struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_new(struct LDKThirtyTwoBytes chain_hash_arg, uint64_t short_channel_id_arg, uint32_t timestamp_arg, uint8_t flags_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, struct LDKCVec_u8Z excess_data_arg);
26516 export function UnsignedChannelUpdate_new(chain_hash_arg: number, short_channel_id_arg: bigint, timestamp_arg: number, flags_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fee_base_msat_arg: number, fee_proportional_millionths_arg: number, excess_data_arg: number): bigint {
26517 if(!isWasmInitialized) {
26518 throw new Error("initializeWasm() must be awaited first!");
26520 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_new(chain_hash_arg, short_channel_id_arg, timestamp_arg, flags_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fee_base_msat_arg, fee_proportional_millionths_arg, excess_data_arg);
26521 return nativeResponseValue;
26523 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
26525 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
26526 if(!isWasmInitialized) {
26527 throw new Error("initializeWasm() must be awaited first!");
26529 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
26530 return nativeResponseValue;
26532 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
26534 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
26535 if(!isWasmInitialized) {
26536 throw new Error("initializeWasm() must be awaited first!");
26538 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
26539 return nativeResponseValue;
26541 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
26543 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
26544 if(!isWasmInitialized) {
26545 throw new Error("initializeWasm() must be awaited first!");
26547 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
26548 return nativeResponseValue;
26550 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
26552 export function ChannelUpdate_free(this_obj: bigint): void {
26553 if(!isWasmInitialized) {
26554 throw new Error("initializeWasm() must be awaited first!");
26556 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
26557 // debug statements here
26559 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
26561 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
26562 if(!isWasmInitialized) {
26563 throw new Error("initializeWasm() must be awaited first!");
26565 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
26566 return nativeResponseValue;
26568 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
26570 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
26571 if(!isWasmInitialized) {
26572 throw new Error("initializeWasm() must be awaited first!");
26574 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
26575 // debug statements here
26577 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
26579 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
26580 if(!isWasmInitialized) {
26581 throw new Error("initializeWasm() must be awaited first!");
26583 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
26584 return nativeResponseValue;
26586 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
26588 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
26589 if(!isWasmInitialized) {
26590 throw new Error("initializeWasm() must be awaited first!");
26592 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
26593 // debug statements here
26595 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
26597 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
26598 if(!isWasmInitialized) {
26599 throw new Error("initializeWasm() must be awaited first!");
26601 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
26602 return nativeResponseValue;
26604 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
26606 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
26607 if(!isWasmInitialized) {
26608 throw new Error("initializeWasm() must be awaited first!");
26610 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
26611 return nativeResponseValue;
26613 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
26615 export function ChannelUpdate_clone(orig: bigint): bigint {
26616 if(!isWasmInitialized) {
26617 throw new Error("initializeWasm() must be awaited first!");
26619 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
26620 return nativeResponseValue;
26622 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
26624 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
26625 if(!isWasmInitialized) {
26626 throw new Error("initializeWasm() must be awaited first!");
26628 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
26629 return nativeResponseValue;
26631 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
26633 export function QueryChannelRange_free(this_obj: bigint): void {
26634 if(!isWasmInitialized) {
26635 throw new Error("initializeWasm() must be awaited first!");
26637 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
26638 // debug statements here
26640 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
26642 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
26643 if(!isWasmInitialized) {
26644 throw new Error("initializeWasm() must be awaited first!");
26646 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
26647 return nativeResponseValue;
26649 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26651 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
26652 if(!isWasmInitialized) {
26653 throw new Error("initializeWasm() must be awaited first!");
26655 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
26656 // debug statements here
26658 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
26660 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
26661 if(!isWasmInitialized) {
26662 throw new Error("initializeWasm() must be awaited first!");
26664 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
26665 return nativeResponseValue;
26667 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
26669 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
26670 if(!isWasmInitialized) {
26671 throw new Error("initializeWasm() must be awaited first!");
26673 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
26674 // debug statements here
26676 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
26678 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
26679 if(!isWasmInitialized) {
26680 throw new Error("initializeWasm() must be awaited first!");
26682 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
26683 return nativeResponseValue;
26685 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
26687 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
26688 if(!isWasmInitialized) {
26689 throw new Error("initializeWasm() must be awaited first!");
26691 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
26692 // debug statements here
26694 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
26696 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
26697 if(!isWasmInitialized) {
26698 throw new Error("initializeWasm() must be awaited first!");
26700 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
26701 return nativeResponseValue;
26703 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
26705 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
26706 if(!isWasmInitialized) {
26707 throw new Error("initializeWasm() must be awaited first!");
26709 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
26710 return nativeResponseValue;
26712 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
26714 export function QueryChannelRange_clone(orig: bigint): bigint {
26715 if(!isWasmInitialized) {
26716 throw new Error("initializeWasm() must be awaited first!");
26718 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
26719 return nativeResponseValue;
26721 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
26723 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
26724 if(!isWasmInitialized) {
26725 throw new Error("initializeWasm() must be awaited first!");
26727 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
26728 return nativeResponseValue;
26730 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
26732 export function ReplyChannelRange_free(this_obj: bigint): void {
26733 if(!isWasmInitialized) {
26734 throw new Error("initializeWasm() must be awaited first!");
26736 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
26737 // debug statements here
26739 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
26741 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
26742 if(!isWasmInitialized) {
26743 throw new Error("initializeWasm() must be awaited first!");
26745 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
26746 return nativeResponseValue;
26748 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26750 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
26751 if(!isWasmInitialized) {
26752 throw new Error("initializeWasm() must be awaited first!");
26754 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
26755 // debug statements here
26757 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26759 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
26760 if(!isWasmInitialized) {
26761 throw new Error("initializeWasm() must be awaited first!");
26763 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
26764 return nativeResponseValue;
26766 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
26768 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
26769 if(!isWasmInitialized) {
26770 throw new Error("initializeWasm() must be awaited first!");
26772 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
26773 // debug statements here
26775 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26777 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
26778 if(!isWasmInitialized) {
26779 throw new Error("initializeWasm() must be awaited first!");
26781 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
26782 return nativeResponseValue;
26784 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
26786 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
26787 if(!isWasmInitialized) {
26788 throw new Error("initializeWasm() must be awaited first!");
26790 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
26791 // debug statements here
26793 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26795 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
26796 if(!isWasmInitialized) {
26797 throw new Error("initializeWasm() must be awaited first!");
26799 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
26800 return nativeResponseValue;
26802 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
26804 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
26805 if(!isWasmInitialized) {
26806 throw new Error("initializeWasm() must be awaited first!");
26808 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
26809 // debug statements here
26811 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
26813 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
26814 if(!isWasmInitialized) {
26815 throw new Error("initializeWasm() must be awaited first!");
26817 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
26818 return nativeResponseValue;
26820 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
26822 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
26823 if(!isWasmInitialized) {
26824 throw new Error("initializeWasm() must be awaited first!");
26826 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
26827 // debug statements here
26829 // 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);
26831 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): bigint {
26832 if(!isWasmInitialized) {
26833 throw new Error("initializeWasm() must be awaited first!");
26835 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
26836 return nativeResponseValue;
26838 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
26840 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
26841 if(!isWasmInitialized) {
26842 throw new Error("initializeWasm() must be awaited first!");
26844 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
26845 return nativeResponseValue;
26847 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
26849 export function ReplyChannelRange_clone(orig: bigint): bigint {
26850 if(!isWasmInitialized) {
26851 throw new Error("initializeWasm() must be awaited first!");
26853 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
26854 return nativeResponseValue;
26856 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
26858 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
26859 if(!isWasmInitialized) {
26860 throw new Error("initializeWasm() must be awaited first!");
26862 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
26863 return nativeResponseValue;
26865 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
26867 export function QueryShortChannelIds_free(this_obj: bigint): void {
26868 if(!isWasmInitialized) {
26869 throw new Error("initializeWasm() must be awaited first!");
26871 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
26872 // debug statements here
26874 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
26876 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
26877 if(!isWasmInitialized) {
26878 throw new Error("initializeWasm() must be awaited first!");
26880 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
26881 return nativeResponseValue;
26883 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26885 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
26886 if(!isWasmInitialized) {
26887 throw new Error("initializeWasm() must be awaited first!");
26889 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
26890 // debug statements here
26892 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
26894 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
26895 if(!isWasmInitialized) {
26896 throw new Error("initializeWasm() must be awaited first!");
26898 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
26899 return nativeResponseValue;
26901 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
26903 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
26904 if(!isWasmInitialized) {
26905 throw new Error("initializeWasm() must be awaited first!");
26907 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
26908 // debug statements here
26910 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
26912 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
26913 if(!isWasmInitialized) {
26914 throw new Error("initializeWasm() must be awaited first!");
26916 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
26917 return nativeResponseValue;
26919 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
26921 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
26922 if(!isWasmInitialized) {
26923 throw new Error("initializeWasm() must be awaited first!");
26925 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
26926 return nativeResponseValue;
26928 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
26930 export function QueryShortChannelIds_clone(orig: bigint): bigint {
26931 if(!isWasmInitialized) {
26932 throw new Error("initializeWasm() must be awaited first!");
26934 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
26935 return nativeResponseValue;
26937 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
26939 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
26940 if(!isWasmInitialized) {
26941 throw new Error("initializeWasm() must be awaited first!");
26943 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
26944 return nativeResponseValue;
26946 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
26948 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
26949 if(!isWasmInitialized) {
26950 throw new Error("initializeWasm() must be awaited first!");
26952 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
26953 // debug statements here
26955 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
26957 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
26958 if(!isWasmInitialized) {
26959 throw new Error("initializeWasm() must be awaited first!");
26961 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
26962 return nativeResponseValue;
26964 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26966 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
26967 if(!isWasmInitialized) {
26968 throw new Error("initializeWasm() must be awaited first!");
26970 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
26971 // debug statements here
26973 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
26975 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
26976 if(!isWasmInitialized) {
26977 throw new Error("initializeWasm() must be awaited first!");
26979 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
26980 return nativeResponseValue;
26982 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
26984 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
26985 if(!isWasmInitialized) {
26986 throw new Error("initializeWasm() must be awaited first!");
26988 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
26989 // debug statements here
26991 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
26993 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
26994 if(!isWasmInitialized) {
26995 throw new Error("initializeWasm() must be awaited first!");
26997 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
26998 return nativeResponseValue;
27000 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
27002 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
27003 if(!isWasmInitialized) {
27004 throw new Error("initializeWasm() must be awaited first!");
27006 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
27007 return nativeResponseValue;
27009 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
27011 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
27012 if(!isWasmInitialized) {
27013 throw new Error("initializeWasm() must be awaited first!");
27015 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
27016 return nativeResponseValue;
27018 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
27020 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
27021 if(!isWasmInitialized) {
27022 throw new Error("initializeWasm() must be awaited first!");
27024 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
27025 return nativeResponseValue;
27027 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
27029 export function GossipTimestampFilter_free(this_obj: bigint): void {
27030 if(!isWasmInitialized) {
27031 throw new Error("initializeWasm() must be awaited first!");
27033 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
27034 // debug statements here
27036 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
27038 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
27039 if(!isWasmInitialized) {
27040 throw new Error("initializeWasm() must be awaited first!");
27042 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
27043 return nativeResponseValue;
27045 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27047 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
27048 if(!isWasmInitialized) {
27049 throw new Error("initializeWasm() must be awaited first!");
27051 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
27052 // debug statements here
27054 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
27056 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
27057 if(!isWasmInitialized) {
27058 throw new Error("initializeWasm() must be awaited first!");
27060 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
27061 return nativeResponseValue;
27063 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
27065 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
27066 if(!isWasmInitialized) {
27067 throw new Error("initializeWasm() must be awaited first!");
27069 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
27070 // debug statements here
27072 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
27074 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
27075 if(!isWasmInitialized) {
27076 throw new Error("initializeWasm() must be awaited first!");
27078 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
27079 return nativeResponseValue;
27081 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
27083 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
27084 if(!isWasmInitialized) {
27085 throw new Error("initializeWasm() must be awaited first!");
27087 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
27088 // debug statements here
27090 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
27092 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
27093 if(!isWasmInitialized) {
27094 throw new Error("initializeWasm() must be awaited first!");
27096 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
27097 return nativeResponseValue;
27099 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
27101 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
27102 if(!isWasmInitialized) {
27103 throw new Error("initializeWasm() must be awaited first!");
27105 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
27106 return nativeResponseValue;
27108 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
27110 export function GossipTimestampFilter_clone(orig: bigint): bigint {
27111 if(!isWasmInitialized) {
27112 throw new Error("initializeWasm() must be awaited first!");
27114 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
27115 return nativeResponseValue;
27117 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
27119 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
27120 if(!isWasmInitialized) {
27121 throw new Error("initializeWasm() must be awaited first!");
27123 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
27124 return nativeResponseValue;
27126 // void ErrorAction_free(struct LDKErrorAction this_ptr);
27128 export function ErrorAction_free(this_ptr: bigint): void {
27129 if(!isWasmInitialized) {
27130 throw new Error("initializeWasm() must be awaited first!");
27132 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
27133 // debug statements here
27135 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
27137 export function ErrorAction_clone_ptr(arg: bigint): bigint {
27138 if(!isWasmInitialized) {
27139 throw new Error("initializeWasm() must be awaited first!");
27141 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
27142 return nativeResponseValue;
27144 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
27146 export function ErrorAction_clone(orig: bigint): bigint {
27147 if(!isWasmInitialized) {
27148 throw new Error("initializeWasm() must be awaited first!");
27150 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
27151 return nativeResponseValue;
27153 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
27155 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
27156 if(!isWasmInitialized) {
27157 throw new Error("initializeWasm() must be awaited first!");
27159 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
27160 return nativeResponseValue;
27162 // struct LDKErrorAction ErrorAction_ignore_error(void);
27164 export function ErrorAction_ignore_error(): bigint {
27165 if(!isWasmInitialized) {
27166 throw new Error("initializeWasm() must be awaited first!");
27168 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
27169 return nativeResponseValue;
27171 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
27173 export function ErrorAction_ignore_and_log(a: Level): bigint {
27174 if(!isWasmInitialized) {
27175 throw new Error("initializeWasm() must be awaited first!");
27177 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
27178 return nativeResponseValue;
27180 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
27182 export function ErrorAction_ignore_duplicate_gossip(): bigint {
27183 if(!isWasmInitialized) {
27184 throw new Error("initializeWasm() must be awaited first!");
27186 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
27187 return nativeResponseValue;
27189 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
27191 export function ErrorAction_send_error_message(msg: bigint): bigint {
27192 if(!isWasmInitialized) {
27193 throw new Error("initializeWasm() must be awaited first!");
27195 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
27196 return nativeResponseValue;
27198 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
27200 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
27201 if(!isWasmInitialized) {
27202 throw new Error("initializeWasm() must be awaited first!");
27204 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
27205 return nativeResponseValue;
27207 // void LightningError_free(struct LDKLightningError this_obj);
27209 export function LightningError_free(this_obj: bigint): void {
27210 if(!isWasmInitialized) {
27211 throw new Error("initializeWasm() must be awaited first!");
27213 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
27214 // debug statements here
27216 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
27218 export function LightningError_get_err(this_ptr: bigint): number {
27219 if(!isWasmInitialized) {
27220 throw new Error("initializeWasm() must be awaited first!");
27222 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
27223 return nativeResponseValue;
27225 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
27227 export function LightningError_set_err(this_ptr: bigint, val: number): void {
27228 if(!isWasmInitialized) {
27229 throw new Error("initializeWasm() must be awaited first!");
27231 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
27232 // debug statements here
27234 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
27236 export function LightningError_get_action(this_ptr: bigint): bigint {
27237 if(!isWasmInitialized) {
27238 throw new Error("initializeWasm() must be awaited first!");
27240 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
27241 return nativeResponseValue;
27243 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
27245 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
27246 if(!isWasmInitialized) {
27247 throw new Error("initializeWasm() must be awaited first!");
27249 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
27250 // debug statements here
27252 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
27254 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
27255 if(!isWasmInitialized) {
27256 throw new Error("initializeWasm() must be awaited first!");
27258 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
27259 return nativeResponseValue;
27261 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
27263 export function LightningError_clone_ptr(arg: bigint): bigint {
27264 if(!isWasmInitialized) {
27265 throw new Error("initializeWasm() must be awaited first!");
27267 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
27268 return nativeResponseValue;
27270 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
27272 export function LightningError_clone(orig: bigint): bigint {
27273 if(!isWasmInitialized) {
27274 throw new Error("initializeWasm() must be awaited first!");
27276 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
27277 return nativeResponseValue;
27279 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
27281 export function CommitmentUpdate_free(this_obj: bigint): void {
27282 if(!isWasmInitialized) {
27283 throw new Error("initializeWasm() must be awaited first!");
27285 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
27286 // debug statements here
27288 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27290 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
27291 if(!isWasmInitialized) {
27292 throw new Error("initializeWasm() must be awaited first!");
27294 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
27295 return nativeResponseValue;
27297 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
27299 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
27300 if(!isWasmInitialized) {
27301 throw new Error("initializeWasm() must be awaited first!");
27303 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
27304 // debug statements here
27306 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27308 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
27309 if(!isWasmInitialized) {
27310 throw new Error("initializeWasm() must be awaited first!");
27312 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
27313 return nativeResponseValue;
27315 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
27317 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
27318 if(!isWasmInitialized) {
27319 throw new Error("initializeWasm() must be awaited first!");
27321 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
27322 // debug statements here
27324 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27326 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
27327 if(!isWasmInitialized) {
27328 throw new Error("initializeWasm() must be awaited first!");
27330 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
27331 return nativeResponseValue;
27333 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
27335 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
27336 if(!isWasmInitialized) {
27337 throw new Error("initializeWasm() must be awaited first!");
27339 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
27340 // debug statements here
27342 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27344 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
27345 if(!isWasmInitialized) {
27346 throw new Error("initializeWasm() must be awaited first!");
27348 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
27349 return nativeResponseValue;
27351 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
27353 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
27354 if(!isWasmInitialized) {
27355 throw new Error("initializeWasm() must be awaited first!");
27357 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
27358 // debug statements here
27360 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27362 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
27363 if(!isWasmInitialized) {
27364 throw new Error("initializeWasm() must be awaited first!");
27366 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
27367 return nativeResponseValue;
27369 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
27371 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
27372 if(!isWasmInitialized) {
27373 throw new Error("initializeWasm() must be awaited first!");
27375 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
27376 // debug statements here
27378 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
27380 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
27381 if(!isWasmInitialized) {
27382 throw new Error("initializeWasm() must be awaited first!");
27384 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
27385 return nativeResponseValue;
27387 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
27389 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
27390 if(!isWasmInitialized) {
27391 throw new Error("initializeWasm() must be awaited first!");
27393 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
27394 // debug statements here
27396 // 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);
27398 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: bigint, commitment_signed_arg: bigint): bigint {
27399 if(!isWasmInitialized) {
27400 throw new Error("initializeWasm() must be awaited first!");
27402 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);
27403 return nativeResponseValue;
27405 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
27407 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
27408 if(!isWasmInitialized) {
27409 throw new Error("initializeWasm() must be awaited first!");
27411 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
27412 return nativeResponseValue;
27414 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
27416 export function CommitmentUpdate_clone(orig: bigint): bigint {
27417 if(!isWasmInitialized) {
27418 throw new Error("initializeWasm() must be awaited first!");
27420 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
27421 return nativeResponseValue;
27423 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
27425 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
27426 if(!isWasmInitialized) {
27427 throw new Error("initializeWasm() must be awaited first!");
27429 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
27430 return nativeResponseValue;
27432 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
27434 export function ChannelMessageHandler_free(this_ptr: bigint): void {
27435 if(!isWasmInitialized) {
27436 throw new Error("initializeWasm() must be awaited first!");
27438 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
27439 // debug statements here
27441 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
27443 export function RoutingMessageHandler_free(this_ptr: bigint): void {
27444 if(!isWasmInitialized) {
27445 throw new Error("initializeWasm() must be awaited first!");
27447 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
27448 // debug statements here
27450 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
27452 export function OnionMessageHandler_free(this_ptr: bigint): void {
27453 if(!isWasmInitialized) {
27454 throw new Error("initializeWasm() must be awaited first!");
27456 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
27457 // debug statements here
27459 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
27461 export function AcceptChannel_write(obj: bigint): number {
27462 if(!isWasmInitialized) {
27463 throw new Error("initializeWasm() must be awaited first!");
27465 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
27466 return nativeResponseValue;
27468 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
27470 export function AcceptChannel_read(ser: number): bigint {
27471 if(!isWasmInitialized) {
27472 throw new Error("initializeWasm() must be awaited first!");
27474 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
27475 return nativeResponseValue;
27477 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
27479 export function AnnouncementSignatures_write(obj: bigint): number {
27480 if(!isWasmInitialized) {
27481 throw new Error("initializeWasm() must be awaited first!");
27483 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
27484 return nativeResponseValue;
27486 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
27488 export function AnnouncementSignatures_read(ser: number): bigint {
27489 if(!isWasmInitialized) {
27490 throw new Error("initializeWasm() must be awaited first!");
27492 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
27493 return nativeResponseValue;
27495 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
27497 export function ChannelReestablish_write(obj: bigint): number {
27498 if(!isWasmInitialized) {
27499 throw new Error("initializeWasm() must be awaited first!");
27501 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
27502 return nativeResponseValue;
27504 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
27506 export function ChannelReestablish_read(ser: number): bigint {
27507 if(!isWasmInitialized) {
27508 throw new Error("initializeWasm() must be awaited first!");
27510 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
27511 return nativeResponseValue;
27513 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
27515 export function ClosingSigned_write(obj: bigint): number {
27516 if(!isWasmInitialized) {
27517 throw new Error("initializeWasm() must be awaited first!");
27519 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
27520 return nativeResponseValue;
27522 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
27524 export function ClosingSigned_read(ser: number): bigint {
27525 if(!isWasmInitialized) {
27526 throw new Error("initializeWasm() must be awaited first!");
27528 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
27529 return nativeResponseValue;
27531 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
27533 export function ClosingSignedFeeRange_write(obj: bigint): number {
27534 if(!isWasmInitialized) {
27535 throw new Error("initializeWasm() must be awaited first!");
27537 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
27538 return nativeResponseValue;
27540 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
27542 export function ClosingSignedFeeRange_read(ser: number): bigint {
27543 if(!isWasmInitialized) {
27544 throw new Error("initializeWasm() must be awaited first!");
27546 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
27547 return nativeResponseValue;
27549 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
27551 export function CommitmentSigned_write(obj: bigint): number {
27552 if(!isWasmInitialized) {
27553 throw new Error("initializeWasm() must be awaited first!");
27555 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
27556 return nativeResponseValue;
27558 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
27560 export function CommitmentSigned_read(ser: number): bigint {
27561 if(!isWasmInitialized) {
27562 throw new Error("initializeWasm() must be awaited first!");
27564 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
27565 return nativeResponseValue;
27567 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
27569 export function FundingCreated_write(obj: bigint): number {
27570 if(!isWasmInitialized) {
27571 throw new Error("initializeWasm() must be awaited first!");
27573 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
27574 return nativeResponseValue;
27576 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
27578 export function FundingCreated_read(ser: number): bigint {
27579 if(!isWasmInitialized) {
27580 throw new Error("initializeWasm() must be awaited first!");
27582 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
27583 return nativeResponseValue;
27585 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
27587 export function FundingSigned_write(obj: bigint): number {
27588 if(!isWasmInitialized) {
27589 throw new Error("initializeWasm() must be awaited first!");
27591 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
27592 return nativeResponseValue;
27594 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
27596 export function FundingSigned_read(ser: number): bigint {
27597 if(!isWasmInitialized) {
27598 throw new Error("initializeWasm() must be awaited first!");
27600 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
27601 return nativeResponseValue;
27603 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
27605 export function ChannelReady_write(obj: bigint): number {
27606 if(!isWasmInitialized) {
27607 throw new Error("initializeWasm() must be awaited first!");
27609 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
27610 return nativeResponseValue;
27612 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
27614 export function ChannelReady_read(ser: number): bigint {
27615 if(!isWasmInitialized) {
27616 throw new Error("initializeWasm() must be awaited first!");
27618 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
27619 return nativeResponseValue;
27621 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
27623 export function Init_write(obj: bigint): number {
27624 if(!isWasmInitialized) {
27625 throw new Error("initializeWasm() must be awaited first!");
27627 const nativeResponseValue = wasm.TS_Init_write(obj);
27628 return nativeResponseValue;
27630 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
27632 export function Init_read(ser: number): bigint {
27633 if(!isWasmInitialized) {
27634 throw new Error("initializeWasm() must be awaited first!");
27636 const nativeResponseValue = wasm.TS_Init_read(ser);
27637 return nativeResponseValue;
27639 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
27641 export function OpenChannel_write(obj: bigint): number {
27642 if(!isWasmInitialized) {
27643 throw new Error("initializeWasm() must be awaited first!");
27645 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
27646 return nativeResponseValue;
27648 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
27650 export function OpenChannel_read(ser: number): bigint {
27651 if(!isWasmInitialized) {
27652 throw new Error("initializeWasm() must be awaited first!");
27654 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
27655 return nativeResponseValue;
27657 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
27659 export function RevokeAndACK_write(obj: bigint): number {
27660 if(!isWasmInitialized) {
27661 throw new Error("initializeWasm() must be awaited first!");
27663 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
27664 return nativeResponseValue;
27666 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
27668 export function RevokeAndACK_read(ser: number): bigint {
27669 if(!isWasmInitialized) {
27670 throw new Error("initializeWasm() must be awaited first!");
27672 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
27673 return nativeResponseValue;
27675 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
27677 export function Shutdown_write(obj: bigint): number {
27678 if(!isWasmInitialized) {
27679 throw new Error("initializeWasm() must be awaited first!");
27681 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
27682 return nativeResponseValue;
27684 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
27686 export function Shutdown_read(ser: number): bigint {
27687 if(!isWasmInitialized) {
27688 throw new Error("initializeWasm() must be awaited first!");
27690 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
27691 return nativeResponseValue;
27693 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
27695 export function UpdateFailHTLC_write(obj: bigint): number {
27696 if(!isWasmInitialized) {
27697 throw new Error("initializeWasm() must be awaited first!");
27699 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
27700 return nativeResponseValue;
27702 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
27704 export function UpdateFailHTLC_read(ser: number): bigint {
27705 if(!isWasmInitialized) {
27706 throw new Error("initializeWasm() must be awaited first!");
27708 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
27709 return nativeResponseValue;
27711 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
27713 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
27714 if(!isWasmInitialized) {
27715 throw new Error("initializeWasm() must be awaited first!");
27717 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
27718 return nativeResponseValue;
27720 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
27722 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
27723 if(!isWasmInitialized) {
27724 throw new Error("initializeWasm() must be awaited first!");
27726 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
27727 return nativeResponseValue;
27729 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
27731 export function UpdateFee_write(obj: bigint): number {
27732 if(!isWasmInitialized) {
27733 throw new Error("initializeWasm() must be awaited first!");
27735 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
27736 return nativeResponseValue;
27738 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
27740 export function UpdateFee_read(ser: number): bigint {
27741 if(!isWasmInitialized) {
27742 throw new Error("initializeWasm() must be awaited first!");
27744 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
27745 return nativeResponseValue;
27747 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
27749 export function UpdateFulfillHTLC_write(obj: bigint): number {
27750 if(!isWasmInitialized) {
27751 throw new Error("initializeWasm() must be awaited first!");
27753 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
27754 return nativeResponseValue;
27756 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
27758 export function UpdateFulfillHTLC_read(ser: number): bigint {
27759 if(!isWasmInitialized) {
27760 throw new Error("initializeWasm() must be awaited first!");
27762 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
27763 return nativeResponseValue;
27765 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
27767 export function UpdateAddHTLC_write(obj: bigint): number {
27768 if(!isWasmInitialized) {
27769 throw new Error("initializeWasm() must be awaited first!");
27771 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
27772 return nativeResponseValue;
27774 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
27776 export function UpdateAddHTLC_read(ser: number): bigint {
27777 if(!isWasmInitialized) {
27778 throw new Error("initializeWasm() must be awaited first!");
27780 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
27781 return nativeResponseValue;
27783 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
27785 export function OnionMessage_read(ser: number): bigint {
27786 if(!isWasmInitialized) {
27787 throw new Error("initializeWasm() must be awaited first!");
27789 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
27790 return nativeResponseValue;
27792 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
27794 export function OnionMessage_write(obj: bigint): number {
27795 if(!isWasmInitialized) {
27796 throw new Error("initializeWasm() must be awaited first!");
27798 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
27799 return nativeResponseValue;
27801 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
27803 export function Ping_write(obj: bigint): number {
27804 if(!isWasmInitialized) {
27805 throw new Error("initializeWasm() must be awaited first!");
27807 const nativeResponseValue = wasm.TS_Ping_write(obj);
27808 return nativeResponseValue;
27810 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
27812 export function Ping_read(ser: number): bigint {
27813 if(!isWasmInitialized) {
27814 throw new Error("initializeWasm() must be awaited first!");
27816 const nativeResponseValue = wasm.TS_Ping_read(ser);
27817 return nativeResponseValue;
27819 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
27821 export function Pong_write(obj: bigint): number {
27822 if(!isWasmInitialized) {
27823 throw new Error("initializeWasm() must be awaited first!");
27825 const nativeResponseValue = wasm.TS_Pong_write(obj);
27826 return nativeResponseValue;
27828 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
27830 export function Pong_read(ser: number): bigint {
27831 if(!isWasmInitialized) {
27832 throw new Error("initializeWasm() must be awaited first!");
27834 const nativeResponseValue = wasm.TS_Pong_read(ser);
27835 return nativeResponseValue;
27837 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
27839 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
27840 if(!isWasmInitialized) {
27841 throw new Error("initializeWasm() must be awaited first!");
27843 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
27844 return nativeResponseValue;
27846 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
27848 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
27849 if(!isWasmInitialized) {
27850 throw new Error("initializeWasm() must be awaited first!");
27852 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
27853 return nativeResponseValue;
27855 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
27857 export function ChannelAnnouncement_write(obj: bigint): number {
27858 if(!isWasmInitialized) {
27859 throw new Error("initializeWasm() must be awaited first!");
27861 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
27862 return nativeResponseValue;
27864 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
27866 export function ChannelAnnouncement_read(ser: number): bigint {
27867 if(!isWasmInitialized) {
27868 throw new Error("initializeWasm() must be awaited first!");
27870 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
27871 return nativeResponseValue;
27873 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
27875 export function UnsignedChannelUpdate_write(obj: bigint): number {
27876 if(!isWasmInitialized) {
27877 throw new Error("initializeWasm() must be awaited first!");
27879 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
27880 return nativeResponseValue;
27882 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
27884 export function UnsignedChannelUpdate_read(ser: number): bigint {
27885 if(!isWasmInitialized) {
27886 throw new Error("initializeWasm() must be awaited first!");
27888 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
27889 return nativeResponseValue;
27891 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
27893 export function ChannelUpdate_write(obj: bigint): number {
27894 if(!isWasmInitialized) {
27895 throw new Error("initializeWasm() must be awaited first!");
27897 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
27898 return nativeResponseValue;
27900 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
27902 export function ChannelUpdate_read(ser: number): bigint {
27903 if(!isWasmInitialized) {
27904 throw new Error("initializeWasm() must be awaited first!");
27906 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
27907 return nativeResponseValue;
27909 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
27911 export function ErrorMessage_write(obj: bigint): number {
27912 if(!isWasmInitialized) {
27913 throw new Error("initializeWasm() must be awaited first!");
27915 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
27916 return nativeResponseValue;
27918 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
27920 export function ErrorMessage_read(ser: number): bigint {
27921 if(!isWasmInitialized) {
27922 throw new Error("initializeWasm() must be awaited first!");
27924 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
27925 return nativeResponseValue;
27927 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
27929 export function WarningMessage_write(obj: bigint): number {
27930 if(!isWasmInitialized) {
27931 throw new Error("initializeWasm() must be awaited first!");
27933 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
27934 return nativeResponseValue;
27936 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
27938 export function WarningMessage_read(ser: number): bigint {
27939 if(!isWasmInitialized) {
27940 throw new Error("initializeWasm() must be awaited first!");
27942 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
27943 return nativeResponseValue;
27945 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
27947 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
27948 if(!isWasmInitialized) {
27949 throw new Error("initializeWasm() must be awaited first!");
27951 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
27952 return nativeResponseValue;
27954 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
27956 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
27957 if(!isWasmInitialized) {
27958 throw new Error("initializeWasm() must be awaited first!");
27960 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
27961 return nativeResponseValue;
27963 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
27965 export function NodeAnnouncement_write(obj: bigint): number {
27966 if(!isWasmInitialized) {
27967 throw new Error("initializeWasm() must be awaited first!");
27969 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
27970 return nativeResponseValue;
27972 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
27974 export function NodeAnnouncement_read(ser: number): bigint {
27975 if(!isWasmInitialized) {
27976 throw new Error("initializeWasm() must be awaited first!");
27978 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
27979 return nativeResponseValue;
27981 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
27983 export function QueryShortChannelIds_read(ser: number): bigint {
27984 if(!isWasmInitialized) {
27985 throw new Error("initializeWasm() must be awaited first!");
27987 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
27988 return nativeResponseValue;
27990 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
27992 export function QueryShortChannelIds_write(obj: bigint): number {
27993 if(!isWasmInitialized) {
27994 throw new Error("initializeWasm() must be awaited first!");
27996 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
27997 return nativeResponseValue;
27999 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
28001 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
28002 if(!isWasmInitialized) {
28003 throw new Error("initializeWasm() must be awaited first!");
28005 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
28006 return nativeResponseValue;
28008 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
28010 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
28011 if(!isWasmInitialized) {
28012 throw new Error("initializeWasm() must be awaited first!");
28014 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
28015 return nativeResponseValue;
28017 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
28019 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
28020 if(!isWasmInitialized) {
28021 throw new Error("initializeWasm() must be awaited first!");
28023 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
28024 return nativeResponseValue;
28026 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
28028 export function QueryChannelRange_write(obj: bigint): number {
28029 if(!isWasmInitialized) {
28030 throw new Error("initializeWasm() must be awaited first!");
28032 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
28033 return nativeResponseValue;
28035 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
28037 export function QueryChannelRange_read(ser: number): bigint {
28038 if(!isWasmInitialized) {
28039 throw new Error("initializeWasm() must be awaited first!");
28041 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
28042 return nativeResponseValue;
28044 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
28046 export function ReplyChannelRange_read(ser: number): bigint {
28047 if(!isWasmInitialized) {
28048 throw new Error("initializeWasm() must be awaited first!");
28050 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
28051 return nativeResponseValue;
28053 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
28055 export function ReplyChannelRange_write(obj: bigint): number {
28056 if(!isWasmInitialized) {
28057 throw new Error("initializeWasm() must be awaited first!");
28059 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
28060 return nativeResponseValue;
28062 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
28064 export function GossipTimestampFilter_write(obj: bigint): number {
28065 if(!isWasmInitialized) {
28066 throw new Error("initializeWasm() must be awaited first!");
28068 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
28069 return nativeResponseValue;
28071 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
28073 export function GossipTimestampFilter_read(ser: number): bigint {
28074 if(!isWasmInitialized) {
28075 throw new Error("initializeWasm() must be awaited first!");
28077 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
28078 return nativeResponseValue;
28080 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
28082 export function CustomMessageHandler_free(this_ptr: bigint): void {
28083 if(!isWasmInitialized) {
28084 throw new Error("initializeWasm() must be awaited first!");
28086 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
28087 // debug statements here
28089 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
28091 export function IgnoringMessageHandler_free(this_obj: bigint): void {
28092 if(!isWasmInitialized) {
28093 throw new Error("initializeWasm() must be awaited first!");
28095 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
28096 // debug statements here
28098 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
28100 export function IgnoringMessageHandler_new(): bigint {
28101 if(!isWasmInitialized) {
28102 throw new Error("initializeWasm() must be awaited first!");
28104 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
28105 return nativeResponseValue;
28107 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28109 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
28110 if(!isWasmInitialized) {
28111 throw new Error("initializeWasm() must be awaited first!");
28113 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
28114 return nativeResponseValue;
28116 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28118 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
28119 if(!isWasmInitialized) {
28120 throw new Error("initializeWasm() must be awaited first!");
28122 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
28123 return nativeResponseValue;
28125 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28127 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
28128 if(!isWasmInitialized) {
28129 throw new Error("initializeWasm() must be awaited first!");
28131 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
28132 return nativeResponseValue;
28134 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28136 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
28137 if(!isWasmInitialized) {
28138 throw new Error("initializeWasm() must be awaited first!");
28140 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
28141 return nativeResponseValue;
28143 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28145 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
28146 if(!isWasmInitialized) {
28147 throw new Error("initializeWasm() must be awaited first!");
28149 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
28150 return nativeResponseValue;
28152 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28154 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
28155 if(!isWasmInitialized) {
28156 throw new Error("initializeWasm() must be awaited first!");
28158 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
28159 return nativeResponseValue;
28161 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
28163 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
28164 if(!isWasmInitialized) {
28165 throw new Error("initializeWasm() must be awaited first!");
28167 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
28168 return nativeResponseValue;
28170 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
28172 export function ErroringMessageHandler_free(this_obj: bigint): void {
28173 if(!isWasmInitialized) {
28174 throw new Error("initializeWasm() must be awaited first!");
28176 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
28177 // debug statements here
28179 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
28181 export function ErroringMessageHandler_new(): bigint {
28182 if(!isWasmInitialized) {
28183 throw new Error("initializeWasm() must be awaited first!");
28185 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
28186 return nativeResponseValue;
28188 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
28190 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
28191 if(!isWasmInitialized) {
28192 throw new Error("initializeWasm() must be awaited first!");
28194 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
28195 return nativeResponseValue;
28197 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
28199 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
28200 if(!isWasmInitialized) {
28201 throw new Error("initializeWasm() must be awaited first!");
28203 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
28204 return nativeResponseValue;
28206 // void MessageHandler_free(struct LDKMessageHandler this_obj);
28208 export function MessageHandler_free(this_obj: bigint): void {
28209 if(!isWasmInitialized) {
28210 throw new Error("initializeWasm() must be awaited first!");
28212 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
28213 // debug statements here
28215 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
28217 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
28218 if(!isWasmInitialized) {
28219 throw new Error("initializeWasm() must be awaited first!");
28221 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
28222 return nativeResponseValue;
28224 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
28226 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
28227 if(!isWasmInitialized) {
28228 throw new Error("initializeWasm() must be awaited first!");
28230 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
28231 // debug statements here
28233 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
28235 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
28236 if(!isWasmInitialized) {
28237 throw new Error("initializeWasm() must be awaited first!");
28239 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
28240 return nativeResponseValue;
28242 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
28244 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
28245 if(!isWasmInitialized) {
28246 throw new Error("initializeWasm() must be awaited first!");
28248 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
28249 // debug statements here
28251 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
28253 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
28254 if(!isWasmInitialized) {
28255 throw new Error("initializeWasm() must be awaited first!");
28257 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
28258 return nativeResponseValue;
28260 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
28262 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
28263 if(!isWasmInitialized) {
28264 throw new Error("initializeWasm() must be awaited first!");
28266 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
28267 // debug statements here
28269 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg);
28271 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint): bigint {
28272 if(!isWasmInitialized) {
28273 throw new Error("initializeWasm() must be awaited first!");
28275 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg);
28276 return nativeResponseValue;
28278 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
28280 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
28281 if(!isWasmInitialized) {
28282 throw new Error("initializeWasm() must be awaited first!");
28284 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
28285 return nativeResponseValue;
28287 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
28289 export function SocketDescriptor_clone(orig: bigint): bigint {
28290 if(!isWasmInitialized) {
28291 throw new Error("initializeWasm() must be awaited first!");
28293 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
28294 return nativeResponseValue;
28296 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
28298 export function SocketDescriptor_free(this_ptr: bigint): void {
28299 if(!isWasmInitialized) {
28300 throw new Error("initializeWasm() must be awaited first!");
28302 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
28303 // debug statements here
28305 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
28307 export function PeerHandleError_free(this_obj: bigint): void {
28308 if(!isWasmInitialized) {
28309 throw new Error("initializeWasm() must be awaited first!");
28311 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
28312 // debug statements here
28314 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
28316 export function PeerHandleError_get_no_connection_possible(this_ptr: bigint): boolean {
28317 if(!isWasmInitialized) {
28318 throw new Error("initializeWasm() must be awaited first!");
28320 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
28321 return nativeResponseValue;
28323 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
28325 export function PeerHandleError_set_no_connection_possible(this_ptr: bigint, val: boolean): void {
28326 if(!isWasmInitialized) {
28327 throw new Error("initializeWasm() must be awaited first!");
28329 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
28330 // debug statements here
28332 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
28334 export function PeerHandleError_new(no_connection_possible_arg: boolean): bigint {
28335 if(!isWasmInitialized) {
28336 throw new Error("initializeWasm() must be awaited first!");
28338 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
28339 return nativeResponseValue;
28341 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
28343 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
28344 if(!isWasmInitialized) {
28345 throw new Error("initializeWasm() must be awaited first!");
28347 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
28348 return nativeResponseValue;
28350 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
28352 export function PeerHandleError_clone(orig: bigint): bigint {
28353 if(!isWasmInitialized) {
28354 throw new Error("initializeWasm() must be awaited first!");
28356 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
28357 return nativeResponseValue;
28359 // void PeerManager_free(struct LDKPeerManager this_obj);
28361 export function PeerManager_free(this_obj: bigint): void {
28362 if(!isWasmInitialized) {
28363 throw new Error("initializeWasm() must be awaited first!");
28365 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
28366 // debug statements here
28368 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, uint32_t current_time, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
28370 export function PeerManager_new(message_handler: bigint, our_node_secret: number, current_time: number, ephemeral_random_data: number, logger: bigint, custom_message_handler: bigint): bigint {
28371 if(!isWasmInitialized) {
28372 throw new Error("initializeWasm() must be awaited first!");
28374 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, current_time, ephemeral_random_data, logger, custom_message_handler);
28375 return nativeResponseValue;
28377 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
28379 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
28380 if(!isWasmInitialized) {
28381 throw new Error("initializeWasm() must be awaited first!");
28383 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
28384 return nativeResponseValue;
28386 // 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);
28388 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
28389 if(!isWasmInitialized) {
28390 throw new Error("initializeWasm() must be awaited first!");
28392 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
28393 return nativeResponseValue;
28395 // 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);
28397 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
28398 if(!isWasmInitialized) {
28399 throw new Error("initializeWasm() must be awaited first!");
28401 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
28402 return nativeResponseValue;
28404 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
28406 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
28407 if(!isWasmInitialized) {
28408 throw new Error("initializeWasm() must be awaited first!");
28410 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
28411 return nativeResponseValue;
28413 // 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);
28415 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
28416 if(!isWasmInitialized) {
28417 throw new Error("initializeWasm() must be awaited first!");
28419 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
28420 return nativeResponseValue;
28422 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
28424 export function PeerManager_process_events(this_arg: bigint): void {
28425 if(!isWasmInitialized) {
28426 throw new Error("initializeWasm() must be awaited first!");
28428 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
28429 // debug statements here
28431 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
28433 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
28434 if(!isWasmInitialized) {
28435 throw new Error("initializeWasm() must be awaited first!");
28437 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
28438 // debug statements here
28440 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
28442 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number, no_connection_possible: boolean): void {
28443 if(!isWasmInitialized) {
28444 throw new Error("initializeWasm() must be awaited first!");
28446 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
28447 // debug statements here
28449 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
28451 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
28452 if(!isWasmInitialized) {
28453 throw new Error("initializeWasm() must be awaited first!");
28455 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
28456 // debug statements here
28458 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
28460 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
28461 if(!isWasmInitialized) {
28462 throw new Error("initializeWasm() must be awaited first!");
28464 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
28465 // debug statements here
28467 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
28469 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
28470 if(!isWasmInitialized) {
28471 throw new Error("initializeWasm() must be awaited first!");
28473 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
28474 // debug statements here
28476 // uint64_t htlc_success_tx_weight(bool opt_anchors);
28478 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
28479 if(!isWasmInitialized) {
28480 throw new Error("initializeWasm() must be awaited first!");
28482 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
28483 return nativeResponseValue;
28485 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
28487 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
28488 if(!isWasmInitialized) {
28489 throw new Error("initializeWasm() must be awaited first!");
28491 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
28492 return nativeResponseValue;
28494 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
28496 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
28497 if(!isWasmInitialized) {
28498 throw new Error("initializeWasm() must be awaited first!");
28500 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
28501 return nativeResponseValue;
28503 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
28505 export function HTLCClaim_offered_timeout(): HTLCClaim {
28506 if(!isWasmInitialized) {
28507 throw new Error("initializeWasm() must be awaited first!");
28509 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
28510 return nativeResponseValue;
28512 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
28514 export function HTLCClaim_offered_preimage(): HTLCClaim {
28515 if(!isWasmInitialized) {
28516 throw new Error("initializeWasm() must be awaited first!");
28518 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
28519 return nativeResponseValue;
28521 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
28523 export function HTLCClaim_accepted_timeout(): HTLCClaim {
28524 if(!isWasmInitialized) {
28525 throw new Error("initializeWasm() must be awaited first!");
28527 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
28528 return nativeResponseValue;
28530 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
28532 export function HTLCClaim_accepted_preimage(): HTLCClaim {
28533 if(!isWasmInitialized) {
28534 throw new Error("initializeWasm() must be awaited first!");
28536 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
28537 return nativeResponseValue;
28539 // enum LDKHTLCClaim HTLCClaim_revocation(void);
28541 export function HTLCClaim_revocation(): HTLCClaim {
28542 if(!isWasmInitialized) {
28543 throw new Error("initializeWasm() must be awaited first!");
28545 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
28546 return nativeResponseValue;
28548 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
28550 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
28551 if(!isWasmInitialized) {
28552 throw new Error("initializeWasm() must be awaited first!");
28554 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
28555 return nativeResponseValue;
28557 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
28559 export function HTLCClaim_from_witness(witness: number): bigint {
28560 if(!isWasmInitialized) {
28561 throw new Error("initializeWasm() must be awaited first!");
28563 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
28564 return nativeResponseValue;
28566 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
28568 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
28569 if(!isWasmInitialized) {
28570 throw new Error("initializeWasm() must be awaited first!");
28572 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
28573 return nativeResponseValue;
28575 // 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);
28577 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: bigint): number {
28578 if(!isWasmInitialized) {
28579 throw new Error("initializeWasm() must be awaited first!");
28581 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
28582 return nativeResponseValue;
28584 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
28586 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
28587 if(!isWasmInitialized) {
28588 throw new Error("initializeWasm() must be awaited first!");
28590 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
28591 // debug statements here
28593 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
28595 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
28596 if(!isWasmInitialized) {
28597 throw new Error("initializeWasm() must be awaited first!");
28599 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
28600 return nativeResponseValue;
28602 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
28604 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
28605 if(!isWasmInitialized) {
28606 throw new Error("initializeWasm() must be awaited first!");
28608 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
28609 return nativeResponseValue;
28611 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
28613 export function CounterpartyCommitmentSecrets_new(): bigint {
28614 if(!isWasmInitialized) {
28615 throw new Error("initializeWasm() must be awaited first!");
28617 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
28618 return nativeResponseValue;
28620 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
28622 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
28623 if(!isWasmInitialized) {
28624 throw new Error("initializeWasm() must be awaited first!");
28626 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
28627 return nativeResponseValue;
28629 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
28631 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
28632 if(!isWasmInitialized) {
28633 throw new Error("initializeWasm() must be awaited first!");
28635 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
28636 return nativeResponseValue;
28638 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
28640 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
28641 if(!isWasmInitialized) {
28642 throw new Error("initializeWasm() must be awaited first!");
28644 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
28645 return nativeResponseValue;
28647 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
28649 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
28650 if(!isWasmInitialized) {
28651 throw new Error("initializeWasm() must be awaited first!");
28653 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
28654 return nativeResponseValue;
28656 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
28658 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
28659 if(!isWasmInitialized) {
28660 throw new Error("initializeWasm() must be awaited first!");
28662 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
28663 return nativeResponseValue;
28665 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
28667 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
28668 if(!isWasmInitialized) {
28669 throw new Error("initializeWasm() must be awaited first!");
28671 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
28672 return nativeResponseValue;
28674 // struct LDKPublicKey derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
28676 export function derive_public_key(per_commitment_point: number, base_point: number): number {
28677 if(!isWasmInitialized) {
28678 throw new Error("initializeWasm() must be awaited first!");
28680 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
28681 return nativeResponseValue;
28683 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
28685 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
28686 if(!isWasmInitialized) {
28687 throw new Error("initializeWasm() must be awaited first!");
28689 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
28690 return nativeResponseValue;
28692 // struct LDKPublicKey derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
28694 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
28695 if(!isWasmInitialized) {
28696 throw new Error("initializeWasm() must be awaited first!");
28698 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
28699 return nativeResponseValue;
28701 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
28703 export function TxCreationKeys_free(this_obj: bigint): void {
28704 if(!isWasmInitialized) {
28705 throw new Error("initializeWasm() must be awaited first!");
28707 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
28708 // debug statements here
28710 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
28712 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
28713 if(!isWasmInitialized) {
28714 throw new Error("initializeWasm() must be awaited first!");
28716 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
28717 return nativeResponseValue;
28719 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28721 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
28722 if(!isWasmInitialized) {
28723 throw new Error("initializeWasm() must be awaited first!");
28725 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
28726 // debug statements here
28728 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
28730 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
28731 if(!isWasmInitialized) {
28732 throw new Error("initializeWasm() must be awaited first!");
28734 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
28735 return nativeResponseValue;
28737 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28739 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
28740 if(!isWasmInitialized) {
28741 throw new Error("initializeWasm() must be awaited first!");
28743 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
28744 // debug statements here
28746 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
28748 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
28749 if(!isWasmInitialized) {
28750 throw new Error("initializeWasm() must be awaited first!");
28752 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
28753 return nativeResponseValue;
28755 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28757 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
28758 if(!isWasmInitialized) {
28759 throw new Error("initializeWasm() must be awaited first!");
28761 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
28762 // debug statements here
28764 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
28766 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
28767 if(!isWasmInitialized) {
28768 throw new Error("initializeWasm() must be awaited first!");
28770 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
28771 return nativeResponseValue;
28773 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28775 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
28776 if(!isWasmInitialized) {
28777 throw new Error("initializeWasm() must be awaited first!");
28779 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
28780 // debug statements here
28782 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
28784 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
28785 if(!isWasmInitialized) {
28786 throw new Error("initializeWasm() must be awaited first!");
28788 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
28789 return nativeResponseValue;
28791 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28793 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
28794 if(!isWasmInitialized) {
28795 throw new Error("initializeWasm() must be awaited first!");
28797 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
28798 // debug statements here
28800 // 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);
28802 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): bigint {
28803 if(!isWasmInitialized) {
28804 throw new Error("initializeWasm() must be awaited first!");
28806 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);
28807 return nativeResponseValue;
28809 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
28811 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
28812 if(!isWasmInitialized) {
28813 throw new Error("initializeWasm() must be awaited first!");
28815 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
28816 return nativeResponseValue;
28818 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
28820 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
28821 if(!isWasmInitialized) {
28822 throw new Error("initializeWasm() must be awaited first!");
28824 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
28825 return nativeResponseValue;
28827 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
28829 export function TxCreationKeys_clone(orig: bigint): bigint {
28830 if(!isWasmInitialized) {
28831 throw new Error("initializeWasm() must be awaited first!");
28833 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
28834 return nativeResponseValue;
28836 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
28838 export function TxCreationKeys_write(obj: bigint): number {
28839 if(!isWasmInitialized) {
28840 throw new Error("initializeWasm() must be awaited first!");
28842 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
28843 return nativeResponseValue;
28845 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
28847 export function TxCreationKeys_read(ser: number): bigint {
28848 if(!isWasmInitialized) {
28849 throw new Error("initializeWasm() must be awaited first!");
28851 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
28852 return nativeResponseValue;
28854 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
28856 export function ChannelPublicKeys_free(this_obj: bigint): void {
28857 if(!isWasmInitialized) {
28858 throw new Error("initializeWasm() must be awaited first!");
28860 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
28861 // debug statements here
28863 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28865 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
28866 if(!isWasmInitialized) {
28867 throw new Error("initializeWasm() must be awaited first!");
28869 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
28870 return nativeResponseValue;
28872 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28874 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
28875 if(!isWasmInitialized) {
28876 throw new Error("initializeWasm() must be awaited first!");
28878 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
28879 // debug statements here
28881 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28883 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
28884 if(!isWasmInitialized) {
28885 throw new Error("initializeWasm() must be awaited first!");
28887 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
28888 return nativeResponseValue;
28890 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28892 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
28893 if(!isWasmInitialized) {
28894 throw new Error("initializeWasm() must be awaited first!");
28896 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
28897 // debug statements here
28899 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28901 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
28902 if(!isWasmInitialized) {
28903 throw new Error("initializeWasm() must be awaited first!");
28905 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
28906 return nativeResponseValue;
28908 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28910 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
28911 if(!isWasmInitialized) {
28912 throw new Error("initializeWasm() must be awaited first!");
28914 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
28915 // debug statements here
28917 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28919 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
28920 if(!isWasmInitialized) {
28921 throw new Error("initializeWasm() must be awaited first!");
28923 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
28924 return nativeResponseValue;
28926 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28928 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
28929 if(!isWasmInitialized) {
28930 throw new Error("initializeWasm() must be awaited first!");
28932 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
28933 // debug statements here
28935 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
28937 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
28938 if(!isWasmInitialized) {
28939 throw new Error("initializeWasm() must be awaited first!");
28941 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
28942 return nativeResponseValue;
28944 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28946 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
28947 if(!isWasmInitialized) {
28948 throw new Error("initializeWasm() must be awaited first!");
28950 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
28951 // debug statements here
28953 // 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);
28955 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): bigint {
28956 if(!isWasmInitialized) {
28957 throw new Error("initializeWasm() must be awaited first!");
28959 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
28960 return nativeResponseValue;
28962 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
28964 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
28965 if(!isWasmInitialized) {
28966 throw new Error("initializeWasm() must be awaited first!");
28968 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
28969 return nativeResponseValue;
28971 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
28973 export function ChannelPublicKeys_clone(orig: bigint): bigint {
28974 if(!isWasmInitialized) {
28975 throw new Error("initializeWasm() must be awaited first!");
28977 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
28978 return nativeResponseValue;
28980 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
28982 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
28983 if(!isWasmInitialized) {
28984 throw new Error("initializeWasm() must be awaited first!");
28986 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
28987 return nativeResponseValue;
28989 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
28991 export function ChannelPublicKeys_write(obj: bigint): number {
28992 if(!isWasmInitialized) {
28993 throw new Error("initializeWasm() must be awaited first!");
28995 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
28996 return nativeResponseValue;
28998 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
29000 export function ChannelPublicKeys_read(ser: number): bigint {
29001 if(!isWasmInitialized) {
29002 throw new Error("initializeWasm() must be awaited first!");
29004 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
29005 return nativeResponseValue;
29007 // MUST_USE_RES struct LDKTxCreationKeys 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);
29009 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): bigint {
29010 if(!isWasmInitialized) {
29011 throw new Error("initializeWasm() must be awaited first!");
29013 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
29014 return nativeResponseValue;
29016 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_from_channel_static_keys(struct LDKPublicKey per_commitment_point, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
29018 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
29019 if(!isWasmInitialized) {
29020 throw new Error("initializeWasm() must be awaited first!");
29022 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
29023 return nativeResponseValue;
29025 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
29027 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
29028 if(!isWasmInitialized) {
29029 throw new Error("initializeWasm() must be awaited first!");
29031 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
29032 return nativeResponseValue;
29034 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
29036 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
29037 if(!isWasmInitialized) {
29038 throw new Error("initializeWasm() must be awaited first!");
29040 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
29041 // debug statements here
29043 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29045 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
29046 if(!isWasmInitialized) {
29047 throw new Error("initializeWasm() must be awaited first!");
29049 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
29050 return nativeResponseValue;
29052 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
29054 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
29055 if(!isWasmInitialized) {
29056 throw new Error("initializeWasm() must be awaited first!");
29058 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
29059 // debug statements here
29061 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29063 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
29064 if(!isWasmInitialized) {
29065 throw new Error("initializeWasm() must be awaited first!");
29067 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
29068 return nativeResponseValue;
29070 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
29072 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
29073 if(!isWasmInitialized) {
29074 throw new Error("initializeWasm() must be awaited first!");
29076 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
29077 // debug statements here
29079 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29081 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
29082 if(!isWasmInitialized) {
29083 throw new Error("initializeWasm() must be awaited first!");
29085 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
29086 return nativeResponseValue;
29088 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
29090 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
29091 if(!isWasmInitialized) {
29092 throw new Error("initializeWasm() must be awaited first!");
29094 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
29095 // debug statements here
29097 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
29099 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
29100 if(!isWasmInitialized) {
29101 throw new Error("initializeWasm() must be awaited first!");
29103 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
29104 return nativeResponseValue;
29106 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29108 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
29109 if(!isWasmInitialized) {
29110 throw new Error("initializeWasm() must be awaited first!");
29112 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
29113 // debug statements here
29115 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
29117 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
29118 if(!isWasmInitialized) {
29119 throw new Error("initializeWasm() must be awaited first!");
29121 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
29122 return nativeResponseValue;
29124 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
29126 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
29127 if(!isWasmInitialized) {
29128 throw new Error("initializeWasm() must be awaited first!");
29130 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
29131 // debug statements here
29133 // 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);
29135 export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, transaction_output_index_arg: bigint): bigint {
29136 if(!isWasmInitialized) {
29137 throw new Error("initializeWasm() must be awaited first!");
29139 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
29140 return nativeResponseValue;
29142 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
29144 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
29145 if(!isWasmInitialized) {
29146 throw new Error("initializeWasm() must be awaited first!");
29148 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
29149 return nativeResponseValue;
29151 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
29153 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
29154 if(!isWasmInitialized) {
29155 throw new Error("initializeWasm() must be awaited first!");
29157 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
29158 return nativeResponseValue;
29160 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
29162 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
29163 if(!isWasmInitialized) {
29164 throw new Error("initializeWasm() must be awaited first!");
29166 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
29167 return nativeResponseValue;
29169 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
29171 export function HTLCOutputInCommitment_write(obj: bigint): number {
29172 if(!isWasmInitialized) {
29173 throw new Error("initializeWasm() must be awaited first!");
29175 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
29176 return nativeResponseValue;
29178 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
29180 export function HTLCOutputInCommitment_read(ser: number): bigint {
29181 if(!isWasmInitialized) {
29182 throw new Error("initializeWasm() must be awaited first!");
29184 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
29185 return nativeResponseValue;
29187 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
29189 export function get_htlc_redeemscript(htlc: bigint, opt_anchors: boolean, keys: bigint): number {
29190 if(!isWasmInitialized) {
29191 throw new Error("initializeWasm() must be awaited first!");
29193 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
29194 return nativeResponseValue;
29196 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
29198 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
29199 if(!isWasmInitialized) {
29200 throw new Error("initializeWasm() must be awaited first!");
29202 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
29203 return nativeResponseValue;
29205 // 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, bool use_non_zero_fee_anchors, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
29207 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, opt_anchors: boolean, use_non_zero_fee_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
29208 if(!isWasmInitialized) {
29209 throw new Error("initializeWasm() must be awaited first!");
29211 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, use_non_zero_fee_anchors, broadcaster_delayed_payment_key, revocation_key);
29212 return nativeResponseValue;
29214 // struct LDKWitness build_htlc_input_witness(struct LDKSignature local_sig, struct LDKSignature remote_sig, struct LDKThirtyTwoBytes preimage, struct LDKu8slice redeem_script, bool opt_anchors);
29216 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: number, redeem_script: number, opt_anchors: boolean): number {
29217 if(!isWasmInitialized) {
29218 throw new Error("initializeWasm() must be awaited first!");
29220 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, opt_anchors);
29221 return nativeResponseValue;
29223 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
29225 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
29226 if(!isWasmInitialized) {
29227 throw new Error("initializeWasm() must be awaited first!");
29229 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
29230 return nativeResponseValue;
29232 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
29234 export function get_anchor_redeemscript(funding_pubkey: number): number {
29235 if(!isWasmInitialized) {
29236 throw new Error("initializeWasm() must be awaited first!");
29238 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
29239 return nativeResponseValue;
29241 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKSignature funding_sig);
29243 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
29244 if(!isWasmInitialized) {
29245 throw new Error("initializeWasm() must be awaited first!");
29247 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
29248 return nativeResponseValue;
29250 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
29252 export function ChannelTransactionParameters_free(this_obj: bigint): void {
29253 if(!isWasmInitialized) {
29254 throw new Error("initializeWasm() must be awaited first!");
29256 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
29257 // debug statements here
29259 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29261 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
29262 if(!isWasmInitialized) {
29263 throw new Error("initializeWasm() must be awaited first!");
29265 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
29266 return nativeResponseValue;
29268 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
29270 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
29271 if(!isWasmInitialized) {
29272 throw new Error("initializeWasm() must be awaited first!");
29274 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
29275 // debug statements here
29277 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29279 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
29280 if(!isWasmInitialized) {
29281 throw new Error("initializeWasm() must be awaited first!");
29283 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
29284 return nativeResponseValue;
29286 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
29288 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
29289 if(!isWasmInitialized) {
29290 throw new Error("initializeWasm() must be awaited first!");
29292 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
29293 // debug statements here
29295 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29297 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
29298 if(!isWasmInitialized) {
29299 throw new Error("initializeWasm() must be awaited first!");
29301 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
29302 return nativeResponseValue;
29304 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
29306 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
29307 if(!isWasmInitialized) {
29308 throw new Error("initializeWasm() must be awaited first!");
29310 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
29311 // debug statements here
29313 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29315 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
29316 if(!isWasmInitialized) {
29317 throw new Error("initializeWasm() must be awaited first!");
29319 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
29320 return nativeResponseValue;
29322 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
29324 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
29325 if(!isWasmInitialized) {
29326 throw new Error("initializeWasm() must be awaited first!");
29328 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
29329 // debug statements here
29331 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29333 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
29334 if(!isWasmInitialized) {
29335 throw new Error("initializeWasm() must be awaited first!");
29337 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
29338 return nativeResponseValue;
29340 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
29342 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
29343 if(!isWasmInitialized) {
29344 throw new Error("initializeWasm() must be awaited first!");
29346 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
29347 // debug statements here
29349 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29351 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: bigint): COption_NoneZ {
29352 if(!isWasmInitialized) {
29353 throw new Error("initializeWasm() must be awaited first!");
29355 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
29356 return nativeResponseValue;
29358 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
29360 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: bigint, val: COption_NoneZ): void {
29361 if(!isWasmInitialized) {
29362 throw new Error("initializeWasm() must be awaited first!");
29364 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
29365 // debug statements here
29367 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_non_zero_fee_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
29369 export function ChannelTransactionParameters_get_opt_non_zero_fee_anchors(this_ptr: bigint): COption_NoneZ {
29370 if(!isWasmInitialized) {
29371 throw new Error("initializeWasm() must be awaited first!");
29373 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_non_zero_fee_anchors(this_ptr);
29374 return nativeResponseValue;
29376 // void ChannelTransactionParameters_set_opt_non_zero_fee_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
29378 export function ChannelTransactionParameters_set_opt_non_zero_fee_anchors(this_ptr: bigint, val: COption_NoneZ): void {
29379 if(!isWasmInitialized) {
29380 throw new Error("initializeWasm() must be awaited first!");
29382 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_non_zero_fee_anchors(this_ptr, val);
29383 // debug statements here
29385 // 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, enum LDKCOption_NoneZ opt_non_zero_fee_anchors_arg);
29387 export function ChannelTransactionParameters_new(holder_pubkeys_arg: bigint, holder_selected_contest_delay_arg: number, is_outbound_from_holder_arg: boolean, counterparty_parameters_arg: bigint, funding_outpoint_arg: bigint, opt_anchors_arg: COption_NoneZ, opt_non_zero_fee_anchors_arg: COption_NoneZ): bigint {
29388 if(!isWasmInitialized) {
29389 throw new Error("initializeWasm() must be awaited first!");
29391 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, opt_non_zero_fee_anchors_arg);
29392 return nativeResponseValue;
29394 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
29396 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
29397 if(!isWasmInitialized) {
29398 throw new Error("initializeWasm() must be awaited first!");
29400 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
29401 return nativeResponseValue;
29403 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
29405 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
29406 if(!isWasmInitialized) {
29407 throw new Error("initializeWasm() must be awaited first!");
29409 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
29410 return nativeResponseValue;
29412 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
29414 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
29415 if(!isWasmInitialized) {
29416 throw new Error("initializeWasm() must be awaited first!");
29418 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
29419 // debug statements here
29421 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
29423 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
29424 if(!isWasmInitialized) {
29425 throw new Error("initializeWasm() must be awaited first!");
29427 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
29428 return nativeResponseValue;
29430 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
29432 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
29433 if(!isWasmInitialized) {
29434 throw new Error("initializeWasm() must be awaited first!");
29436 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
29437 // debug statements here
29439 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
29441 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
29442 if(!isWasmInitialized) {
29443 throw new Error("initializeWasm() must be awaited first!");
29445 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
29446 return nativeResponseValue;
29448 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
29450 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
29451 if(!isWasmInitialized) {
29452 throw new Error("initializeWasm() must be awaited first!");
29454 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
29455 // debug statements here
29457 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
29459 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
29460 if(!isWasmInitialized) {
29461 throw new Error("initializeWasm() must be awaited first!");
29463 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
29464 return nativeResponseValue;
29466 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
29468 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
29469 if(!isWasmInitialized) {
29470 throw new Error("initializeWasm() must be awaited first!");
29472 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
29473 return nativeResponseValue;
29475 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
29477 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
29478 if(!isWasmInitialized) {
29479 throw new Error("initializeWasm() must be awaited first!");
29481 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
29482 return nativeResponseValue;
29484 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
29486 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
29487 if(!isWasmInitialized) {
29488 throw new Error("initializeWasm() must be awaited first!");
29490 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
29491 return nativeResponseValue;
29493 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
29495 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
29496 if(!isWasmInitialized) {
29497 throw new Error("initializeWasm() must be awaited first!");
29499 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
29500 return nativeResponseValue;
29502 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
29504 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
29505 if(!isWasmInitialized) {
29506 throw new Error("initializeWasm() must be awaited first!");
29508 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
29509 return nativeResponseValue;
29511 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
29513 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
29514 if(!isWasmInitialized) {
29515 throw new Error("initializeWasm() must be awaited first!");
29517 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
29518 return nativeResponseValue;
29520 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
29522 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
29523 if(!isWasmInitialized) {
29524 throw new Error("initializeWasm() must be awaited first!");
29526 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
29527 return nativeResponseValue;
29529 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
29531 export function ChannelTransactionParameters_write(obj: bigint): number {
29532 if(!isWasmInitialized) {
29533 throw new Error("initializeWasm() must be awaited first!");
29535 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
29536 return nativeResponseValue;
29538 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
29540 export function ChannelTransactionParameters_read(ser: number): bigint {
29541 if(!isWasmInitialized) {
29542 throw new Error("initializeWasm() must be awaited first!");
29544 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
29545 return nativeResponseValue;
29547 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
29549 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
29550 if(!isWasmInitialized) {
29551 throw new Error("initializeWasm() must be awaited first!");
29553 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
29554 // debug statements here
29556 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29558 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
29559 if(!isWasmInitialized) {
29560 throw new Error("initializeWasm() must be awaited first!");
29562 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
29563 return nativeResponseValue;
29565 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29567 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
29568 if(!isWasmInitialized) {
29569 throw new Error("initializeWasm() must be awaited first!");
29571 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
29572 return nativeResponseValue;
29574 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29576 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
29577 if(!isWasmInitialized) {
29578 throw new Error("initializeWasm() must be awaited first!");
29580 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
29581 return nativeResponseValue;
29583 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29585 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
29586 if(!isWasmInitialized) {
29587 throw new Error("initializeWasm() must be awaited first!");
29589 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
29590 return nativeResponseValue;
29592 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29594 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
29595 if(!isWasmInitialized) {
29596 throw new Error("initializeWasm() must be awaited first!");
29598 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
29599 return nativeResponseValue;
29601 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
29603 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: bigint): boolean {
29604 if(!isWasmInitialized) {
29605 throw new Error("initializeWasm() must be awaited first!");
29607 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
29608 return nativeResponseValue;
29610 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
29612 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
29613 if(!isWasmInitialized) {
29614 throw new Error("initializeWasm() must be awaited first!");
29616 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
29617 // debug statements here
29619 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
29621 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
29622 if(!isWasmInitialized) {
29623 throw new Error("initializeWasm() must be awaited first!");
29625 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
29626 return nativeResponseValue;
29628 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
29630 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
29631 if(!isWasmInitialized) {
29632 throw new Error("initializeWasm() must be awaited first!");
29634 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
29635 // debug statements here
29637 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
29639 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
29640 if(!isWasmInitialized) {
29641 throw new Error("initializeWasm() must be awaited first!");
29643 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
29644 return nativeResponseValue;
29646 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
29648 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
29649 if(!isWasmInitialized) {
29650 throw new Error("initializeWasm() must be awaited first!");
29652 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
29653 // debug statements here
29655 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
29657 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
29658 if(!isWasmInitialized) {
29659 throw new Error("initializeWasm() must be awaited first!");
29661 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
29662 return nativeResponseValue;
29664 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
29666 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
29667 if(!isWasmInitialized) {
29668 throw new Error("initializeWasm() must be awaited first!");
29670 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
29671 return nativeResponseValue;
29673 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
29675 export function HolderCommitmentTransaction_write(obj: bigint): number {
29676 if(!isWasmInitialized) {
29677 throw new Error("initializeWasm() must be awaited first!");
29679 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
29680 return nativeResponseValue;
29682 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
29684 export function HolderCommitmentTransaction_read(ser: number): bigint {
29685 if(!isWasmInitialized) {
29686 throw new Error("initializeWasm() must be awaited first!");
29688 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
29689 return nativeResponseValue;
29691 // 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);
29693 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
29694 if(!isWasmInitialized) {
29695 throw new Error("initializeWasm() must be awaited first!");
29697 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
29698 return nativeResponseValue;
29700 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
29702 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
29703 if(!isWasmInitialized) {
29704 throw new Error("initializeWasm() must be awaited first!");
29706 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
29707 // debug statements here
29709 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
29711 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
29712 if(!isWasmInitialized) {
29713 throw new Error("initializeWasm() must be awaited first!");
29715 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
29716 return nativeResponseValue;
29718 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
29720 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
29721 if(!isWasmInitialized) {
29722 throw new Error("initializeWasm() must be awaited first!");
29724 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
29725 // debug statements here
29727 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
29729 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
29730 if(!isWasmInitialized) {
29731 throw new Error("initializeWasm() must be awaited first!");
29733 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
29734 return nativeResponseValue;
29736 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29738 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
29739 if(!isWasmInitialized) {
29740 throw new Error("initializeWasm() must be awaited first!");
29742 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
29743 // debug statements here
29745 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
29747 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
29748 if(!isWasmInitialized) {
29749 throw new Error("initializeWasm() must be awaited first!");
29751 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
29752 return nativeResponseValue;
29754 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
29756 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
29757 if(!isWasmInitialized) {
29758 throw new Error("initializeWasm() must be awaited first!");
29760 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
29761 return nativeResponseValue;
29763 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
29765 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
29766 if(!isWasmInitialized) {
29767 throw new Error("initializeWasm() must be awaited first!");
29769 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
29770 return nativeResponseValue;
29772 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
29774 export function BuiltCommitmentTransaction_write(obj: bigint): number {
29775 if(!isWasmInitialized) {
29776 throw new Error("initializeWasm() must be awaited first!");
29778 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
29779 return nativeResponseValue;
29781 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
29783 export function BuiltCommitmentTransaction_read(ser: number): bigint {
29784 if(!isWasmInitialized) {
29785 throw new Error("initializeWasm() must be awaited first!");
29787 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
29788 return nativeResponseValue;
29790 // 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);
29792 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29793 if(!isWasmInitialized) {
29794 throw new Error("initializeWasm() must be awaited first!");
29796 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
29797 return nativeResponseValue;
29799 // 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);
29801 export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29802 if(!isWasmInitialized) {
29803 throw new Error("initializeWasm() must be awaited first!");
29805 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
29806 return nativeResponseValue;
29808 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
29810 export function ClosingTransaction_free(this_obj: bigint): void {
29811 if(!isWasmInitialized) {
29812 throw new Error("initializeWasm() must be awaited first!");
29814 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
29815 // debug statements here
29817 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
29819 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
29820 if(!isWasmInitialized) {
29821 throw new Error("initializeWasm() must be awaited first!");
29823 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
29824 return nativeResponseValue;
29826 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
29828 export function ClosingTransaction_clone(orig: bigint): bigint {
29829 if(!isWasmInitialized) {
29830 throw new Error("initializeWasm() must be awaited first!");
29832 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
29833 return nativeResponseValue;
29835 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
29837 export function ClosingTransaction_hash(o: bigint): bigint {
29838 if(!isWasmInitialized) {
29839 throw new Error("initializeWasm() must be awaited first!");
29841 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
29842 return nativeResponseValue;
29844 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
29846 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
29847 if(!isWasmInitialized) {
29848 throw new Error("initializeWasm() must be awaited first!");
29850 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
29851 return nativeResponseValue;
29853 // 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);
29855 export function ClosingTransaction_new(to_holder_value_sat: bigint, to_counterparty_value_sat: bigint, to_holder_script: number, to_counterparty_script: number, funding_outpoint: bigint): bigint {
29856 if(!isWasmInitialized) {
29857 throw new Error("initializeWasm() must be awaited first!");
29859 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
29860 return nativeResponseValue;
29862 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29864 export function ClosingTransaction_trust(this_arg: bigint): bigint {
29865 if(!isWasmInitialized) {
29866 throw new Error("initializeWasm() must be awaited first!");
29868 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
29869 return nativeResponseValue;
29871 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
29873 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
29874 if(!isWasmInitialized) {
29875 throw new Error("initializeWasm() must be awaited first!");
29877 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
29878 return nativeResponseValue;
29880 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29882 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
29883 if(!isWasmInitialized) {
29884 throw new Error("initializeWasm() must be awaited first!");
29886 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
29887 return nativeResponseValue;
29889 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29891 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
29892 if(!isWasmInitialized) {
29893 throw new Error("initializeWasm() must be awaited first!");
29895 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
29896 return nativeResponseValue;
29898 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29900 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
29901 if(!isWasmInitialized) {
29902 throw new Error("initializeWasm() must be awaited first!");
29904 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
29905 return nativeResponseValue;
29907 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
29909 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
29910 if(!isWasmInitialized) {
29911 throw new Error("initializeWasm() must be awaited first!");
29913 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
29914 return nativeResponseValue;
29916 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
29918 export function TrustedClosingTransaction_free(this_obj: bigint): void {
29919 if(!isWasmInitialized) {
29920 throw new Error("initializeWasm() must be awaited first!");
29922 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
29923 // debug statements here
29925 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
29927 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
29928 if(!isWasmInitialized) {
29929 throw new Error("initializeWasm() must be awaited first!");
29931 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
29932 return nativeResponseValue;
29934 // 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);
29936 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29937 if(!isWasmInitialized) {
29938 throw new Error("initializeWasm() must be awaited first!");
29940 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
29941 return nativeResponseValue;
29943 // 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);
29945 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
29946 if(!isWasmInitialized) {
29947 throw new Error("initializeWasm() must be awaited first!");
29949 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
29950 return nativeResponseValue;
29952 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
29954 export function CommitmentTransaction_free(this_obj: bigint): void {
29955 if(!isWasmInitialized) {
29956 throw new Error("initializeWasm() must be awaited first!");
29958 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
29959 // debug statements here
29961 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
29963 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
29964 if(!isWasmInitialized) {
29965 throw new Error("initializeWasm() must be awaited first!");
29967 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
29968 return nativeResponseValue;
29970 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
29972 export function CommitmentTransaction_clone(orig: bigint): bigint {
29973 if(!isWasmInitialized) {
29974 throw new Error("initializeWasm() must be awaited first!");
29976 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
29977 return nativeResponseValue;
29979 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
29981 export function CommitmentTransaction_write(obj: bigint): number {
29982 if(!isWasmInitialized) {
29983 throw new Error("initializeWasm() must be awaited first!");
29985 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
29986 return nativeResponseValue;
29988 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
29990 export function CommitmentTransaction_read(ser: number): bigint {
29991 if(!isWasmInitialized) {
29992 throw new Error("initializeWasm() must be awaited first!");
29994 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
29995 return nativeResponseValue;
29997 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
29999 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
30000 if(!isWasmInitialized) {
30001 throw new Error("initializeWasm() must be awaited first!");
30003 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
30004 return nativeResponseValue;
30006 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30008 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
30009 if(!isWasmInitialized) {
30010 throw new Error("initializeWasm() must be awaited first!");
30012 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
30013 return nativeResponseValue;
30015 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30017 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
30018 if(!isWasmInitialized) {
30019 throw new Error("initializeWasm() must be awaited first!");
30021 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
30022 return nativeResponseValue;
30024 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30026 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
30027 if(!isWasmInitialized) {
30028 throw new Error("initializeWasm() must be awaited first!");
30030 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
30031 return nativeResponseValue;
30033 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
30035 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
30036 if(!isWasmInitialized) {
30037 throw new Error("initializeWasm() must be awaited first!");
30039 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
30040 return nativeResponseValue;
30042 // 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);
30044 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
30045 if(!isWasmInitialized) {
30046 throw new Error("initializeWasm() must be awaited first!");
30048 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
30049 return nativeResponseValue;
30051 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
30053 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
30054 if(!isWasmInitialized) {
30055 throw new Error("initializeWasm() must be awaited first!");
30057 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
30058 // debug statements here
30060 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30062 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
30063 if(!isWasmInitialized) {
30064 throw new Error("initializeWasm() must be awaited first!");
30066 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
30067 return nativeResponseValue;
30069 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30071 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
30072 if(!isWasmInitialized) {
30073 throw new Error("initializeWasm() must be awaited first!");
30075 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
30076 return nativeResponseValue;
30078 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30080 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
30081 if(!isWasmInitialized) {
30082 throw new Error("initializeWasm() must be awaited first!");
30084 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
30085 return nativeResponseValue;
30087 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
30089 export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): boolean {
30090 if(!isWasmInitialized) {
30091 throw new Error("initializeWasm() must be awaited first!");
30093 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
30094 return nativeResponseValue;
30096 // 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);
30098 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
30099 if(!isWasmInitialized) {
30100 throw new Error("initializeWasm() must be awaited first!");
30102 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
30103 return nativeResponseValue;
30105 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
30107 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
30108 if(!isWasmInitialized) {
30109 throw new Error("initializeWasm() must be awaited first!");
30111 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
30112 return nativeResponseValue;
30114 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
30116 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
30117 if(!isWasmInitialized) {
30118 throw new Error("initializeWasm() must be awaited first!");
30120 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
30121 return nativeResponseValue;
30123 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
30125 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
30126 if(!isWasmInitialized) {
30127 throw new Error("initializeWasm() must be awaited first!");
30129 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
30130 return nativeResponseValue;
30132 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
30134 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
30135 if(!isWasmInitialized) {
30136 throw new Error("initializeWasm() must be awaited first!");
30138 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
30139 return nativeResponseValue;
30141 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
30143 export function InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
30144 if(!isWasmInitialized) {
30145 throw new Error("initializeWasm() must be awaited first!");
30147 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
30148 return nativeResponseValue;
30150 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
30152 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
30153 if(!isWasmInitialized) {
30154 throw new Error("initializeWasm() must be awaited first!");
30156 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
30157 return nativeResponseValue;
30159 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
30161 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
30162 if(!isWasmInitialized) {
30163 throw new Error("initializeWasm() must be awaited first!");
30165 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
30166 return nativeResponseValue;
30168 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
30170 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
30171 if(!isWasmInitialized) {
30172 throw new Error("initializeWasm() must be awaited first!");
30174 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
30175 return nativeResponseValue;
30177 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
30179 export function InitFeatures_clone_ptr(arg: bigint): bigint {
30180 if(!isWasmInitialized) {
30181 throw new Error("initializeWasm() must be awaited first!");
30183 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
30184 return nativeResponseValue;
30186 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
30188 export function InitFeatures_clone(orig: bigint): bigint {
30189 if(!isWasmInitialized) {
30190 throw new Error("initializeWasm() must be awaited first!");
30192 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
30193 return nativeResponseValue;
30195 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
30197 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
30198 if(!isWasmInitialized) {
30199 throw new Error("initializeWasm() must be awaited first!");
30201 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
30202 return nativeResponseValue;
30204 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
30206 export function NodeFeatures_clone(orig: bigint): bigint {
30207 if(!isWasmInitialized) {
30208 throw new Error("initializeWasm() must be awaited first!");
30210 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
30211 return nativeResponseValue;
30213 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
30215 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
30216 if(!isWasmInitialized) {
30217 throw new Error("initializeWasm() must be awaited first!");
30219 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
30220 return nativeResponseValue;
30222 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
30224 export function ChannelFeatures_clone(orig: bigint): bigint {
30225 if(!isWasmInitialized) {
30226 throw new Error("initializeWasm() must be awaited first!");
30228 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
30229 return nativeResponseValue;
30231 // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
30233 export function InvoiceFeatures_clone_ptr(arg: bigint): bigint {
30234 if(!isWasmInitialized) {
30235 throw new Error("initializeWasm() must be awaited first!");
30237 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
30238 return nativeResponseValue;
30240 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
30242 export function InvoiceFeatures_clone(orig: bigint): bigint {
30243 if(!isWasmInitialized) {
30244 throw new Error("initializeWasm() must be awaited first!");
30246 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
30247 return nativeResponseValue;
30249 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
30251 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
30252 if(!isWasmInitialized) {
30253 throw new Error("initializeWasm() must be awaited first!");
30255 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
30256 return nativeResponseValue;
30258 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
30260 export function OfferFeatures_clone(orig: bigint): bigint {
30261 if(!isWasmInitialized) {
30262 throw new Error("initializeWasm() must be awaited first!");
30264 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
30265 return nativeResponseValue;
30267 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
30269 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
30270 if(!isWasmInitialized) {
30271 throw new Error("initializeWasm() must be awaited first!");
30273 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
30274 return nativeResponseValue;
30276 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
30278 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
30279 if(!isWasmInitialized) {
30280 throw new Error("initializeWasm() must be awaited first!");
30282 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
30283 return nativeResponseValue;
30285 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
30287 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
30288 if(!isWasmInitialized) {
30289 throw new Error("initializeWasm() must be awaited first!");
30291 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
30292 return nativeResponseValue;
30294 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
30296 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
30297 if(!isWasmInitialized) {
30298 throw new Error("initializeWasm() must be awaited first!");
30300 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
30301 return nativeResponseValue;
30303 // void InitFeatures_free(struct LDKInitFeatures this_obj);
30305 export function InitFeatures_free(this_obj: bigint): void {
30306 if(!isWasmInitialized) {
30307 throw new Error("initializeWasm() must be awaited first!");
30309 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
30310 // debug statements here
30312 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
30314 export function NodeFeatures_free(this_obj: bigint): void {
30315 if(!isWasmInitialized) {
30316 throw new Error("initializeWasm() must be awaited first!");
30318 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
30319 // debug statements here
30321 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
30323 export function ChannelFeatures_free(this_obj: bigint): void {
30324 if(!isWasmInitialized) {
30325 throw new Error("initializeWasm() must be awaited first!");
30327 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
30328 // debug statements here
30330 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
30332 export function InvoiceFeatures_free(this_obj: bigint): void {
30333 if(!isWasmInitialized) {
30334 throw new Error("initializeWasm() must be awaited first!");
30336 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
30337 // debug statements here
30339 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
30341 export function OfferFeatures_free(this_obj: bigint): void {
30342 if(!isWasmInitialized) {
30343 throw new Error("initializeWasm() must be awaited first!");
30345 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
30346 // debug statements here
30348 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
30350 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
30351 if(!isWasmInitialized) {
30352 throw new Error("initializeWasm() must be awaited first!");
30354 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
30355 // debug statements here
30357 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
30359 export function ChannelTypeFeatures_free(this_obj: bigint): void {
30360 if(!isWasmInitialized) {
30361 throw new Error("initializeWasm() must be awaited first!");
30363 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
30364 // debug statements here
30366 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
30368 export function InitFeatures_empty(): bigint {
30369 if(!isWasmInitialized) {
30370 throw new Error("initializeWasm() must be awaited first!");
30372 const nativeResponseValue = wasm.TS_InitFeatures_empty();
30373 return nativeResponseValue;
30375 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30377 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30378 if(!isWasmInitialized) {
30379 throw new Error("initializeWasm() must be awaited first!");
30381 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
30382 return nativeResponseValue;
30384 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
30386 export function NodeFeatures_empty(): bigint {
30387 if(!isWasmInitialized) {
30388 throw new Error("initializeWasm() must be awaited first!");
30390 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
30391 return nativeResponseValue;
30393 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30395 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30396 if(!isWasmInitialized) {
30397 throw new Error("initializeWasm() must be awaited first!");
30399 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
30400 return nativeResponseValue;
30402 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
30404 export function ChannelFeatures_empty(): bigint {
30405 if(!isWasmInitialized) {
30406 throw new Error("initializeWasm() must be awaited first!");
30408 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
30409 return nativeResponseValue;
30411 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
30413 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30414 if(!isWasmInitialized) {
30415 throw new Error("initializeWasm() must be awaited first!");
30417 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
30418 return nativeResponseValue;
30420 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
30422 export function InvoiceFeatures_empty(): bigint {
30423 if(!isWasmInitialized) {
30424 throw new Error("initializeWasm() must be awaited first!");
30426 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
30427 return nativeResponseValue;
30429 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30431 export function InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30432 if(!isWasmInitialized) {
30433 throw new Error("initializeWasm() must be awaited first!");
30435 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
30436 return nativeResponseValue;
30438 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
30440 export function OfferFeatures_empty(): bigint {
30441 if(!isWasmInitialized) {
30442 throw new Error("initializeWasm() must be awaited first!");
30444 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
30445 return nativeResponseValue;
30447 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
30449 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30450 if(!isWasmInitialized) {
30451 throw new Error("initializeWasm() must be awaited first!");
30453 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
30454 return nativeResponseValue;
30456 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
30458 export function InvoiceRequestFeatures_empty(): bigint {
30459 if(!isWasmInitialized) {
30460 throw new Error("initializeWasm() must be awaited first!");
30462 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
30463 return nativeResponseValue;
30465 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
30467 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30468 if(!isWasmInitialized) {
30469 throw new Error("initializeWasm() must be awaited first!");
30471 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
30472 return nativeResponseValue;
30474 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
30476 export function ChannelTypeFeatures_empty(): bigint {
30477 if(!isWasmInitialized) {
30478 throw new Error("initializeWasm() must be awaited first!");
30480 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
30481 return nativeResponseValue;
30483 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
30485 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
30486 if(!isWasmInitialized) {
30487 throw new Error("initializeWasm() must be awaited first!");
30489 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
30490 return nativeResponseValue;
30492 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
30494 export function InitFeatures_write(obj: bigint): number {
30495 if(!isWasmInitialized) {
30496 throw new Error("initializeWasm() must be awaited first!");
30498 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
30499 return nativeResponseValue;
30501 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
30503 export function InitFeatures_read(ser: number): bigint {
30504 if(!isWasmInitialized) {
30505 throw new Error("initializeWasm() must be awaited first!");
30507 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
30508 return nativeResponseValue;
30510 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
30512 export function ChannelFeatures_write(obj: bigint): number {
30513 if(!isWasmInitialized) {
30514 throw new Error("initializeWasm() must be awaited first!");
30516 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
30517 return nativeResponseValue;
30519 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
30521 export function ChannelFeatures_read(ser: number): bigint {
30522 if(!isWasmInitialized) {
30523 throw new Error("initializeWasm() must be awaited first!");
30525 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
30526 return nativeResponseValue;
30528 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
30530 export function NodeFeatures_write(obj: bigint): number {
30531 if(!isWasmInitialized) {
30532 throw new Error("initializeWasm() must be awaited first!");
30534 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
30535 return nativeResponseValue;
30537 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
30539 export function NodeFeatures_read(ser: number): bigint {
30540 if(!isWasmInitialized) {
30541 throw new Error("initializeWasm() must be awaited first!");
30543 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
30544 return nativeResponseValue;
30546 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
30548 export function InvoiceFeatures_write(obj: bigint): number {
30549 if(!isWasmInitialized) {
30550 throw new Error("initializeWasm() must be awaited first!");
30552 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
30553 return nativeResponseValue;
30555 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
30557 export function InvoiceFeatures_read(ser: number): bigint {
30558 if(!isWasmInitialized) {
30559 throw new Error("initializeWasm() must be awaited first!");
30561 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
30562 return nativeResponseValue;
30564 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
30566 export function ChannelTypeFeatures_write(obj: bigint): number {
30567 if(!isWasmInitialized) {
30568 throw new Error("initializeWasm() must be awaited first!");
30570 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
30571 return nativeResponseValue;
30573 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
30575 export function ChannelTypeFeatures_read(ser: number): bigint {
30576 if(!isWasmInitialized) {
30577 throw new Error("initializeWasm() must be awaited first!");
30579 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
30580 return nativeResponseValue;
30582 // struct LDKCVec_u8Z OfferFeatures_write(const struct LDKOfferFeatures *NONNULL_PTR obj);
30584 export function OfferFeatures_write(obj: bigint): number {
30585 if(!isWasmInitialized) {
30586 throw new Error("initializeWasm() must be awaited first!");
30588 const nativeResponseValue = wasm.TS_OfferFeatures_write(obj);
30589 return nativeResponseValue;
30591 // struct LDKCResult_OfferFeaturesDecodeErrorZ OfferFeatures_read(struct LDKu8slice ser);
30593 export function OfferFeatures_read(ser: number): bigint {
30594 if(!isWasmInitialized) {
30595 throw new Error("initializeWasm() must be awaited first!");
30597 const nativeResponseValue = wasm.TS_OfferFeatures_read(ser);
30598 return nativeResponseValue;
30600 // struct LDKCVec_u8Z InvoiceRequestFeatures_write(const struct LDKInvoiceRequestFeatures *NONNULL_PTR obj);
30602 export function InvoiceRequestFeatures_write(obj: bigint): number {
30603 if(!isWasmInitialized) {
30604 throw new Error("initializeWasm() must be awaited first!");
30606 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_write(obj);
30607 return nativeResponseValue;
30609 // struct LDKCResult_InvoiceRequestFeaturesDecodeErrorZ InvoiceRequestFeatures_read(struct LDKu8slice ser);
30611 export function InvoiceRequestFeatures_read(ser: number): bigint {
30612 if(!isWasmInitialized) {
30613 throw new Error("initializeWasm() must be awaited first!");
30615 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_read(ser);
30616 return nativeResponseValue;
30618 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30620 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
30621 if(!isWasmInitialized) {
30622 throw new Error("initializeWasm() must be awaited first!");
30624 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
30625 // debug statements here
30627 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30629 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
30630 if(!isWasmInitialized) {
30631 throw new Error("initializeWasm() must be awaited first!");
30633 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
30634 // debug statements here
30636 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30638 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
30639 if(!isWasmInitialized) {
30640 throw new Error("initializeWasm() must be awaited first!");
30642 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
30643 return nativeResponseValue;
30645 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30647 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
30648 if(!isWasmInitialized) {
30649 throw new Error("initializeWasm() must be awaited first!");
30651 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
30652 // debug statements here
30654 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30656 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
30657 if(!isWasmInitialized) {
30658 throw new Error("initializeWasm() must be awaited first!");
30660 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
30661 // debug statements here
30663 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30665 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
30666 if(!isWasmInitialized) {
30667 throw new Error("initializeWasm() must be awaited first!");
30669 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
30670 return nativeResponseValue;
30672 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30674 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
30675 if(!isWasmInitialized) {
30676 throw new Error("initializeWasm() must be awaited first!");
30678 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
30679 return nativeResponseValue;
30681 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30683 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
30684 if(!isWasmInitialized) {
30685 throw new Error("initializeWasm() must be awaited first!");
30687 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
30688 return nativeResponseValue;
30690 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30692 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
30693 if(!isWasmInitialized) {
30694 throw new Error("initializeWasm() must be awaited first!");
30696 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
30697 // debug statements here
30699 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30701 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
30702 if(!isWasmInitialized) {
30703 throw new Error("initializeWasm() must be awaited first!");
30705 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
30706 // debug statements here
30708 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30710 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
30711 if(!isWasmInitialized) {
30712 throw new Error("initializeWasm() must be awaited first!");
30714 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
30715 return nativeResponseValue;
30717 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30719 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
30720 if(!isWasmInitialized) {
30721 throw new Error("initializeWasm() must be awaited first!");
30723 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
30724 // debug statements here
30726 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30728 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
30729 if(!isWasmInitialized) {
30730 throw new Error("initializeWasm() must be awaited first!");
30732 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
30733 // debug statements here
30735 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30737 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
30738 if(!isWasmInitialized) {
30739 throw new Error("initializeWasm() must be awaited first!");
30741 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
30742 return nativeResponseValue;
30744 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30746 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
30747 if(!isWasmInitialized) {
30748 throw new Error("initializeWasm() must be awaited first!");
30750 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
30751 // debug statements here
30753 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30755 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
30756 if(!isWasmInitialized) {
30757 throw new Error("initializeWasm() must be awaited first!");
30759 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
30760 // debug statements here
30762 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30764 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
30765 if(!isWasmInitialized) {
30766 throw new Error("initializeWasm() must be awaited first!");
30768 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
30769 return nativeResponseValue;
30771 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30773 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
30774 if(!isWasmInitialized) {
30775 throw new Error("initializeWasm() must be awaited first!");
30777 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
30778 return nativeResponseValue;
30780 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30782 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
30783 if(!isWasmInitialized) {
30784 throw new Error("initializeWasm() must be awaited first!");
30786 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
30787 return nativeResponseValue;
30789 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30791 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
30792 if(!isWasmInitialized) {
30793 throw new Error("initializeWasm() must be awaited first!");
30795 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
30796 // debug statements here
30798 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30800 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
30801 if(!isWasmInitialized) {
30802 throw new Error("initializeWasm() must be awaited first!");
30804 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
30805 // debug statements here
30807 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30809 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
30810 if(!isWasmInitialized) {
30811 throw new Error("initializeWasm() must be awaited first!");
30813 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
30814 return nativeResponseValue;
30816 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30818 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
30819 if(!isWasmInitialized) {
30820 throw new Error("initializeWasm() must be awaited first!");
30822 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
30823 // debug statements here
30825 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30827 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
30828 if(!isWasmInitialized) {
30829 throw new Error("initializeWasm() must be awaited first!");
30831 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
30832 // debug statements here
30834 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30836 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
30837 if(!isWasmInitialized) {
30838 throw new Error("initializeWasm() must be awaited first!");
30840 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
30841 return nativeResponseValue;
30843 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30845 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
30846 if(!isWasmInitialized) {
30847 throw new Error("initializeWasm() must be awaited first!");
30849 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
30850 return nativeResponseValue;
30852 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30854 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
30855 if(!isWasmInitialized) {
30856 throw new Error("initializeWasm() must be awaited first!");
30858 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
30859 return nativeResponseValue;
30861 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30863 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
30864 if(!isWasmInitialized) {
30865 throw new Error("initializeWasm() must be awaited first!");
30867 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
30868 // debug statements here
30870 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30872 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
30873 if(!isWasmInitialized) {
30874 throw new Error("initializeWasm() must be awaited first!");
30876 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
30877 // debug statements here
30879 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30881 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
30882 if(!isWasmInitialized) {
30883 throw new Error("initializeWasm() must be awaited first!");
30885 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
30886 return nativeResponseValue;
30888 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30890 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
30891 if(!isWasmInitialized) {
30892 throw new Error("initializeWasm() must be awaited first!");
30894 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
30895 // debug statements here
30897 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30899 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
30900 if(!isWasmInitialized) {
30901 throw new Error("initializeWasm() must be awaited first!");
30903 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
30904 // debug statements here
30906 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30908 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
30909 if(!isWasmInitialized) {
30910 throw new Error("initializeWasm() must be awaited first!");
30912 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
30913 return nativeResponseValue;
30915 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30917 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
30918 if(!isWasmInitialized) {
30919 throw new Error("initializeWasm() must be awaited first!");
30921 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
30922 // debug statements here
30924 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30926 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
30927 if(!isWasmInitialized) {
30928 throw new Error("initializeWasm() must be awaited first!");
30930 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
30931 // debug statements here
30933 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30935 export function InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
30936 if(!isWasmInitialized) {
30937 throw new Error("initializeWasm() must be awaited first!");
30939 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
30940 return nativeResponseValue;
30942 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30944 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
30945 if(!isWasmInitialized) {
30946 throw new Error("initializeWasm() must be awaited first!");
30948 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
30949 return nativeResponseValue;
30951 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
30953 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
30954 if(!isWasmInitialized) {
30955 throw new Error("initializeWasm() must be awaited first!");
30957 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
30958 return nativeResponseValue;
30960 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
30962 export function InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
30963 if(!isWasmInitialized) {
30964 throw new Error("initializeWasm() must be awaited first!");
30966 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
30967 return nativeResponseValue;
30969 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
30971 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
30972 if(!isWasmInitialized) {
30973 throw new Error("initializeWasm() must be awaited first!");
30975 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
30976 // debug statements here
30978 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
30980 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
30981 if(!isWasmInitialized) {
30982 throw new Error("initializeWasm() must be awaited first!");
30984 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
30985 // debug statements here
30987 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
30989 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
30990 if(!isWasmInitialized) {
30991 throw new Error("initializeWasm() must be awaited first!");
30993 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
30994 return nativeResponseValue;
30996 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
30998 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
30999 if(!isWasmInitialized) {
31000 throw new Error("initializeWasm() must be awaited first!");
31002 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
31003 // debug statements here
31005 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31007 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
31008 if(!isWasmInitialized) {
31009 throw new Error("initializeWasm() must be awaited first!");
31011 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
31012 // debug statements here
31014 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31016 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
31017 if(!isWasmInitialized) {
31018 throw new Error("initializeWasm() must be awaited first!");
31020 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
31021 return nativeResponseValue;
31023 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31025 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
31026 if(!isWasmInitialized) {
31027 throw new Error("initializeWasm() must be awaited first!");
31029 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
31030 // debug statements here
31032 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31034 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
31035 if(!isWasmInitialized) {
31036 throw new Error("initializeWasm() must be awaited first!");
31038 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
31039 // debug statements here
31041 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31043 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
31044 if(!isWasmInitialized) {
31045 throw new Error("initializeWasm() must be awaited first!");
31047 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
31048 return nativeResponseValue;
31050 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31052 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
31053 if(!isWasmInitialized) {
31054 throw new Error("initializeWasm() must be awaited first!");
31056 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
31057 return nativeResponseValue;
31059 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31061 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
31062 if(!isWasmInitialized) {
31063 throw new Error("initializeWasm() must be awaited first!");
31065 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
31066 return nativeResponseValue;
31068 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31070 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
31071 if(!isWasmInitialized) {
31072 throw new Error("initializeWasm() must be awaited first!");
31074 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
31075 return nativeResponseValue;
31077 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31079 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
31080 if(!isWasmInitialized) {
31081 throw new Error("initializeWasm() must be awaited first!");
31083 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
31084 // debug statements here
31086 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31088 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
31089 if(!isWasmInitialized) {
31090 throw new Error("initializeWasm() must be awaited first!");
31092 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
31093 // debug statements here
31095 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31097 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
31098 if(!isWasmInitialized) {
31099 throw new Error("initializeWasm() must be awaited first!");
31101 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
31102 return nativeResponseValue;
31104 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31106 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
31107 if(!isWasmInitialized) {
31108 throw new Error("initializeWasm() must be awaited first!");
31110 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
31111 // debug statements here
31113 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31115 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
31116 if(!isWasmInitialized) {
31117 throw new Error("initializeWasm() must be awaited first!");
31119 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
31120 // debug statements here
31122 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31124 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
31125 if(!isWasmInitialized) {
31126 throw new Error("initializeWasm() must be awaited first!");
31128 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
31129 return nativeResponseValue;
31131 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31133 export function InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
31134 if(!isWasmInitialized) {
31135 throw new Error("initializeWasm() must be awaited first!");
31137 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
31138 // debug statements here
31140 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31142 export function InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
31143 if(!isWasmInitialized) {
31144 throw new Error("initializeWasm() must be awaited first!");
31146 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
31147 // debug statements here
31149 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31151 export function InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
31152 if(!isWasmInitialized) {
31153 throw new Error("initializeWasm() must be awaited first!");
31155 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
31156 return nativeResponseValue;
31158 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31160 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
31161 if(!isWasmInitialized) {
31162 throw new Error("initializeWasm() must be awaited first!");
31164 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
31165 return nativeResponseValue;
31167 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31169 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
31170 if(!isWasmInitialized) {
31171 throw new Error("initializeWasm() must be awaited first!");
31173 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
31174 return nativeResponseValue;
31176 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31178 export function InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
31179 if(!isWasmInitialized) {
31180 throw new Error("initializeWasm() must be awaited first!");
31182 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
31183 return nativeResponseValue;
31185 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31187 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
31188 if(!isWasmInitialized) {
31189 throw new Error("initializeWasm() must be awaited first!");
31191 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
31192 // debug statements here
31194 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31196 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
31197 if(!isWasmInitialized) {
31198 throw new Error("initializeWasm() must be awaited first!");
31200 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
31201 // debug statements here
31203 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31205 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
31206 if(!isWasmInitialized) {
31207 throw new Error("initializeWasm() must be awaited first!");
31209 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
31210 return nativeResponseValue;
31212 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31214 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
31215 if(!isWasmInitialized) {
31216 throw new Error("initializeWasm() must be awaited first!");
31218 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
31219 // debug statements here
31221 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31223 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
31224 if(!isWasmInitialized) {
31225 throw new Error("initializeWasm() must be awaited first!");
31227 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
31228 // debug statements here
31230 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31232 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
31233 if(!isWasmInitialized) {
31234 throw new Error("initializeWasm() must be awaited first!");
31236 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
31237 return nativeResponseValue;
31239 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31241 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
31242 if(!isWasmInitialized) {
31243 throw new Error("initializeWasm() must be awaited first!");
31245 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
31246 // debug statements here
31248 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31250 export function InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
31251 if(!isWasmInitialized) {
31252 throw new Error("initializeWasm() must be awaited first!");
31254 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
31255 // debug statements here
31257 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31259 export function InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
31260 if(!isWasmInitialized) {
31261 throw new Error("initializeWasm() must be awaited first!");
31263 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
31264 return nativeResponseValue;
31266 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31268 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
31269 if(!isWasmInitialized) {
31270 throw new Error("initializeWasm() must be awaited first!");
31272 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
31273 return nativeResponseValue;
31275 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31277 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
31278 if(!isWasmInitialized) {
31279 throw new Error("initializeWasm() must be awaited first!");
31281 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
31282 return nativeResponseValue;
31284 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
31286 export function InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
31287 if(!isWasmInitialized) {
31288 throw new Error("initializeWasm() must be awaited first!");
31290 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
31291 return nativeResponseValue;
31293 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31295 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
31296 if(!isWasmInitialized) {
31297 throw new Error("initializeWasm() must be awaited first!");
31299 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
31300 // debug statements here
31302 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31304 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
31305 if(!isWasmInitialized) {
31306 throw new Error("initializeWasm() must be awaited first!");
31308 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
31309 // debug statements here
31311 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31313 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
31314 if(!isWasmInitialized) {
31315 throw new Error("initializeWasm() must be awaited first!");
31317 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
31318 return nativeResponseValue;
31320 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31322 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
31323 if(!isWasmInitialized) {
31324 throw new Error("initializeWasm() must be awaited first!");
31326 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
31327 // debug statements here
31329 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31331 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
31332 if(!isWasmInitialized) {
31333 throw new Error("initializeWasm() must be awaited first!");
31335 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
31336 // debug statements here
31338 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31340 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
31341 if(!isWasmInitialized) {
31342 throw new Error("initializeWasm() must be awaited first!");
31344 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
31345 return nativeResponseValue;
31347 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31349 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
31350 if(!isWasmInitialized) {
31351 throw new Error("initializeWasm() must be awaited first!");
31353 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
31354 return nativeResponseValue;
31356 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31358 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
31359 if(!isWasmInitialized) {
31360 throw new Error("initializeWasm() must be awaited first!");
31362 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
31363 return nativeResponseValue;
31365 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31367 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
31368 if(!isWasmInitialized) {
31369 throw new Error("initializeWasm() must be awaited first!");
31371 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
31372 // debug statements here
31374 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31376 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
31377 if(!isWasmInitialized) {
31378 throw new Error("initializeWasm() must be awaited first!");
31380 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
31381 // debug statements here
31383 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31385 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
31386 if(!isWasmInitialized) {
31387 throw new Error("initializeWasm() must be awaited first!");
31389 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
31390 return nativeResponseValue;
31392 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31394 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
31395 if(!isWasmInitialized) {
31396 throw new Error("initializeWasm() must be awaited first!");
31398 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
31399 // debug statements here
31401 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31403 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
31404 if(!isWasmInitialized) {
31405 throw new Error("initializeWasm() must be awaited first!");
31407 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
31408 // debug statements here
31410 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31412 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
31413 if(!isWasmInitialized) {
31414 throw new Error("initializeWasm() must be awaited first!");
31416 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
31417 return nativeResponseValue;
31419 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31421 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
31422 if(!isWasmInitialized) {
31423 throw new Error("initializeWasm() must be awaited first!");
31425 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
31426 return nativeResponseValue;
31428 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31430 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
31431 if(!isWasmInitialized) {
31432 throw new Error("initializeWasm() must be awaited first!");
31434 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
31435 return nativeResponseValue;
31437 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31439 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
31440 if(!isWasmInitialized) {
31441 throw new Error("initializeWasm() must be awaited first!");
31443 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
31444 // debug statements here
31446 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31448 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
31449 if(!isWasmInitialized) {
31450 throw new Error("initializeWasm() must be awaited first!");
31452 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
31453 // debug statements here
31455 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31457 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
31458 if(!isWasmInitialized) {
31459 throw new Error("initializeWasm() must be awaited first!");
31461 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
31462 return nativeResponseValue;
31464 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31466 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
31467 if(!isWasmInitialized) {
31468 throw new Error("initializeWasm() must be awaited first!");
31470 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
31471 // debug statements here
31473 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31475 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
31476 if(!isWasmInitialized) {
31477 throw new Error("initializeWasm() must be awaited first!");
31479 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
31480 // debug statements here
31482 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31484 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
31485 if(!isWasmInitialized) {
31486 throw new Error("initializeWasm() must be awaited first!");
31488 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
31489 return nativeResponseValue;
31491 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31493 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
31494 if(!isWasmInitialized) {
31495 throw new Error("initializeWasm() must be awaited first!");
31497 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
31498 return nativeResponseValue;
31500 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31502 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
31503 if(!isWasmInitialized) {
31504 throw new Error("initializeWasm() must be awaited first!");
31506 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
31507 return nativeResponseValue;
31509 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31511 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
31512 if(!isWasmInitialized) {
31513 throw new Error("initializeWasm() must be awaited first!");
31515 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
31516 // debug statements here
31518 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31520 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
31521 if(!isWasmInitialized) {
31522 throw new Error("initializeWasm() must be awaited first!");
31524 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
31525 // debug statements here
31527 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31529 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
31530 if(!isWasmInitialized) {
31531 throw new Error("initializeWasm() must be awaited first!");
31533 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
31534 return nativeResponseValue;
31536 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31538 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
31539 if(!isWasmInitialized) {
31540 throw new Error("initializeWasm() must be awaited first!");
31542 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
31543 // debug statements here
31545 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31547 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
31548 if(!isWasmInitialized) {
31549 throw new Error("initializeWasm() must be awaited first!");
31551 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
31552 // debug statements here
31554 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31556 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
31557 if(!isWasmInitialized) {
31558 throw new Error("initializeWasm() must be awaited first!");
31560 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
31561 return nativeResponseValue;
31563 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31565 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
31566 if(!isWasmInitialized) {
31567 throw new Error("initializeWasm() must be awaited first!");
31569 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
31570 return nativeResponseValue;
31572 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31574 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
31575 if(!isWasmInitialized) {
31576 throw new Error("initializeWasm() must be awaited first!");
31578 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
31579 return nativeResponseValue;
31581 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31583 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
31584 if(!isWasmInitialized) {
31585 throw new Error("initializeWasm() must be awaited first!");
31587 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
31588 // debug statements here
31590 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31592 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
31593 if(!isWasmInitialized) {
31594 throw new Error("initializeWasm() must be awaited first!");
31596 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
31597 // debug statements here
31599 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31601 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
31602 if(!isWasmInitialized) {
31603 throw new Error("initializeWasm() must be awaited first!");
31605 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
31606 return nativeResponseValue;
31608 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31610 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
31611 if(!isWasmInitialized) {
31612 throw new Error("initializeWasm() must be awaited first!");
31614 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
31615 // debug statements here
31617 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31619 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
31620 if(!isWasmInitialized) {
31621 throw new Error("initializeWasm() must be awaited first!");
31623 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
31624 // debug statements here
31626 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31628 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
31629 if(!isWasmInitialized) {
31630 throw new Error("initializeWasm() must be awaited first!");
31632 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
31633 return nativeResponseValue;
31635 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31637 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
31638 if(!isWasmInitialized) {
31639 throw new Error("initializeWasm() must be awaited first!");
31641 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
31642 // debug statements here
31644 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31646 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
31647 if(!isWasmInitialized) {
31648 throw new Error("initializeWasm() must be awaited first!");
31650 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
31651 // debug statements here
31653 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31655 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
31656 if(!isWasmInitialized) {
31657 throw new Error("initializeWasm() must be awaited first!");
31659 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
31660 return nativeResponseValue;
31662 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31664 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
31665 if(!isWasmInitialized) {
31666 throw new Error("initializeWasm() must be awaited first!");
31668 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
31669 return nativeResponseValue;
31671 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31673 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
31674 if(!isWasmInitialized) {
31675 throw new Error("initializeWasm() must be awaited first!");
31677 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
31678 return nativeResponseValue;
31680 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31682 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
31683 if(!isWasmInitialized) {
31684 throw new Error("initializeWasm() must be awaited first!");
31686 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
31687 return nativeResponseValue;
31689 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
31691 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
31692 if(!isWasmInitialized) {
31693 throw new Error("initializeWasm() must be awaited first!");
31695 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
31696 // debug statements here
31698 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
31700 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
31701 if(!isWasmInitialized) {
31702 throw new Error("initializeWasm() must be awaited first!");
31704 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
31705 // debug statements here
31707 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31709 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
31710 if(!isWasmInitialized) {
31711 throw new Error("initializeWasm() must be awaited first!");
31713 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
31714 return nativeResponseValue;
31716 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31718 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
31719 if(!isWasmInitialized) {
31720 throw new Error("initializeWasm() must be awaited first!");
31722 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
31723 // debug statements here
31725 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31727 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
31728 if(!isWasmInitialized) {
31729 throw new Error("initializeWasm() must be awaited first!");
31731 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
31732 // debug statements here
31734 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31736 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
31737 if(!isWasmInitialized) {
31738 throw new Error("initializeWasm() must be awaited first!");
31740 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
31741 return nativeResponseValue;
31743 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31745 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
31746 if(!isWasmInitialized) {
31747 throw new Error("initializeWasm() must be awaited first!");
31749 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
31750 // debug statements here
31752 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31754 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
31755 if(!isWasmInitialized) {
31756 throw new Error("initializeWasm() must be awaited first!");
31758 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
31759 // debug statements here
31761 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31763 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
31764 if(!isWasmInitialized) {
31765 throw new Error("initializeWasm() must be awaited first!");
31767 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
31768 return nativeResponseValue;
31770 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
31772 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
31773 if(!isWasmInitialized) {
31774 throw new Error("initializeWasm() must be awaited first!");
31776 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
31777 return nativeResponseValue;
31779 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31781 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
31782 if(!isWasmInitialized) {
31783 throw new Error("initializeWasm() must be awaited first!");
31785 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
31786 return nativeResponseValue;
31788 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
31790 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
31791 if(!isWasmInitialized) {
31792 throw new Error("initializeWasm() must be awaited first!");
31794 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
31795 return nativeResponseValue;
31797 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31799 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
31800 if(!isWasmInitialized) {
31801 throw new Error("initializeWasm() must be awaited first!");
31803 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
31804 // debug statements here
31806 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
31808 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
31809 if(!isWasmInitialized) {
31810 throw new Error("initializeWasm() must be awaited first!");
31812 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
31813 // debug statements here
31815 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31817 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
31818 if(!isWasmInitialized) {
31819 throw new Error("initializeWasm() must be awaited first!");
31821 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
31822 return nativeResponseValue;
31824 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
31826 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
31827 if(!isWasmInitialized) {
31828 throw new Error("initializeWasm() must be awaited first!");
31830 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
31831 return nativeResponseValue;
31833 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
31835 export function ShutdownScript_free(this_obj: bigint): void {
31836 if(!isWasmInitialized) {
31837 throw new Error("initializeWasm() must be awaited first!");
31839 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
31840 // debug statements here
31842 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
31844 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
31845 if(!isWasmInitialized) {
31846 throw new Error("initializeWasm() must be awaited first!");
31848 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
31849 return nativeResponseValue;
31851 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
31853 export function ShutdownScript_clone(orig: bigint): bigint {
31854 if(!isWasmInitialized) {
31855 throw new Error("initializeWasm() must be awaited first!");
31857 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
31858 return nativeResponseValue;
31860 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
31862 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
31863 if(!isWasmInitialized) {
31864 throw new Error("initializeWasm() must be awaited first!");
31866 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
31867 return nativeResponseValue;
31869 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
31871 export function InvalidShutdownScript_free(this_obj: bigint): void {
31872 if(!isWasmInitialized) {
31873 throw new Error("initializeWasm() must be awaited first!");
31875 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
31876 // debug statements here
31878 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
31880 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
31881 if(!isWasmInitialized) {
31882 throw new Error("initializeWasm() must be awaited first!");
31884 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
31885 return nativeResponseValue;
31887 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
31889 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
31890 if(!isWasmInitialized) {
31891 throw new Error("initializeWasm() must be awaited first!");
31893 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
31894 // debug statements here
31896 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
31898 export function InvalidShutdownScript_new(script_arg: number): bigint {
31899 if(!isWasmInitialized) {
31900 throw new Error("initializeWasm() must be awaited first!");
31902 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
31903 return nativeResponseValue;
31905 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
31907 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
31908 if(!isWasmInitialized) {
31909 throw new Error("initializeWasm() must be awaited first!");
31911 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
31912 return nativeResponseValue;
31914 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
31916 export function InvalidShutdownScript_clone(orig: bigint): bigint {
31917 if(!isWasmInitialized) {
31918 throw new Error("initializeWasm() must be awaited first!");
31920 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
31921 return nativeResponseValue;
31923 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
31925 export function ShutdownScript_write(obj: bigint): number {
31926 if(!isWasmInitialized) {
31927 throw new Error("initializeWasm() must be awaited first!");
31929 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
31930 return nativeResponseValue;
31932 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
31934 export function ShutdownScript_read(ser: number): bigint {
31935 if(!isWasmInitialized) {
31936 throw new Error("initializeWasm() must be awaited first!");
31938 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
31939 return nativeResponseValue;
31941 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
31943 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
31944 if(!isWasmInitialized) {
31945 throw new Error("initializeWasm() must be awaited first!");
31947 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
31948 return nativeResponseValue;
31950 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
31952 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
31953 if(!isWasmInitialized) {
31954 throw new Error("initializeWasm() must be awaited first!");
31956 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
31957 return nativeResponseValue;
31959 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
31961 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
31962 if(!isWasmInitialized) {
31963 throw new Error("initializeWasm() must be awaited first!");
31965 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
31966 return nativeResponseValue;
31968 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
31970 export function ShutdownScript_into_inner(this_arg: bigint): number {
31971 if(!isWasmInitialized) {
31972 throw new Error("initializeWasm() must be awaited first!");
31974 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
31975 return nativeResponseValue;
31977 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
31979 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
31980 if(!isWasmInitialized) {
31981 throw new Error("initializeWasm() must be awaited first!");
31983 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
31984 return nativeResponseValue;
31986 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
31988 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
31989 if(!isWasmInitialized) {
31990 throw new Error("initializeWasm() must be awaited first!");
31992 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
31993 return nativeResponseValue;
31995 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
31997 export function CustomMessageReader_free(this_ptr: bigint): void {
31998 if(!isWasmInitialized) {
31999 throw new Error("initializeWasm() must be awaited first!");
32001 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
32002 // debug statements here
32004 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
32006 export function Type_clone_ptr(arg: bigint): bigint {
32007 if(!isWasmInitialized) {
32008 throw new Error("initializeWasm() must be awaited first!");
32010 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
32011 return nativeResponseValue;
32013 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
32015 export function Type_clone(orig: bigint): bigint {
32016 if(!isWasmInitialized) {
32017 throw new Error("initializeWasm() must be awaited first!");
32019 const nativeResponseValue = wasm.TS_Type_clone(orig);
32020 return nativeResponseValue;
32022 // void Type_free(struct LDKType this_ptr);
32024 export function Type_free(this_ptr: bigint): void {
32025 if(!isWasmInitialized) {
32026 throw new Error("initializeWasm() must be awaited first!");
32028 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
32029 // debug statements here
32031 // void NodeId_free(struct LDKNodeId this_obj);
32033 export function NodeId_free(this_obj: bigint): void {
32034 if(!isWasmInitialized) {
32035 throw new Error("initializeWasm() must be awaited first!");
32037 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
32038 // debug statements here
32040 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
32042 export function NodeId_clone_ptr(arg: bigint): bigint {
32043 if(!isWasmInitialized) {
32044 throw new Error("initializeWasm() must be awaited first!");
32046 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
32047 return nativeResponseValue;
32049 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
32051 export function NodeId_clone(orig: bigint): bigint {
32052 if(!isWasmInitialized) {
32053 throw new Error("initializeWasm() must be awaited first!");
32055 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
32056 return nativeResponseValue;
32058 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
32060 export function NodeId_from_pubkey(pubkey: number): bigint {
32061 if(!isWasmInitialized) {
32062 throw new Error("initializeWasm() must be awaited first!");
32064 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
32065 return nativeResponseValue;
32067 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
32069 export function NodeId_as_slice(this_arg: bigint): number {
32070 if(!isWasmInitialized) {
32071 throw new Error("initializeWasm() must be awaited first!");
32073 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
32074 return nativeResponseValue;
32076 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
32078 export function NodeId_hash(o: bigint): bigint {
32079 if(!isWasmInitialized) {
32080 throw new Error("initializeWasm() must be awaited first!");
32082 const nativeResponseValue = wasm.TS_NodeId_hash(o);
32083 return nativeResponseValue;
32085 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
32087 export function NodeId_write(obj: bigint): number {
32088 if(!isWasmInitialized) {
32089 throw new Error("initializeWasm() must be awaited first!");
32091 const nativeResponseValue = wasm.TS_NodeId_write(obj);
32092 return nativeResponseValue;
32094 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
32096 export function NodeId_read(ser: number): bigint {
32097 if(!isWasmInitialized) {
32098 throw new Error("initializeWasm() must be awaited first!");
32100 const nativeResponseValue = wasm.TS_NodeId_read(ser);
32101 return nativeResponseValue;
32103 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
32105 export function NetworkGraph_free(this_obj: bigint): void {
32106 if(!isWasmInitialized) {
32107 throw new Error("initializeWasm() must be awaited first!");
32109 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
32110 // debug statements here
32112 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
32114 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
32115 if(!isWasmInitialized) {
32116 throw new Error("initializeWasm() must be awaited first!");
32118 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
32119 // debug statements here
32121 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
32123 export function NetworkUpdate_free(this_ptr: bigint): void {
32124 if(!isWasmInitialized) {
32125 throw new Error("initializeWasm() must be awaited first!");
32127 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
32128 // debug statements here
32130 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
32132 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
32133 if(!isWasmInitialized) {
32134 throw new Error("initializeWasm() must be awaited first!");
32136 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
32137 return nativeResponseValue;
32139 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
32141 export function NetworkUpdate_clone(orig: bigint): bigint {
32142 if(!isWasmInitialized) {
32143 throw new Error("initializeWasm() must be awaited first!");
32145 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
32146 return nativeResponseValue;
32148 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
32150 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
32151 if(!isWasmInitialized) {
32152 throw new Error("initializeWasm() must be awaited first!");
32154 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
32155 return nativeResponseValue;
32157 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
32159 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
32160 if(!isWasmInitialized) {
32161 throw new Error("initializeWasm() must be awaited first!");
32163 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
32164 return nativeResponseValue;
32166 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
32168 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
32169 if(!isWasmInitialized) {
32170 throw new Error("initializeWasm() must be awaited first!");
32172 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
32173 return nativeResponseValue;
32175 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
32177 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
32178 if(!isWasmInitialized) {
32179 throw new Error("initializeWasm() must be awaited first!");
32181 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
32182 return nativeResponseValue;
32184 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
32186 export function NetworkUpdate_write(obj: bigint): number {
32187 if(!isWasmInitialized) {
32188 throw new Error("initializeWasm() must be awaited first!");
32190 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
32191 return nativeResponseValue;
32193 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
32195 export function NetworkUpdate_read(ser: number): bigint {
32196 if(!isWasmInitialized) {
32197 throw new Error("initializeWasm() must be awaited first!");
32199 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
32200 return nativeResponseValue;
32202 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
32204 export function P2PGossipSync_free(this_obj: bigint): void {
32205 if(!isWasmInitialized) {
32206 throw new Error("initializeWasm() must be awaited first!");
32208 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
32209 // debug statements here
32211 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
32213 export function P2PGossipSync_new(network_graph: bigint, chain_access: bigint, logger: bigint): bigint {
32214 if(!isWasmInitialized) {
32215 throw new Error("initializeWasm() must be awaited first!");
32217 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
32218 return nativeResponseValue;
32220 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
32222 export function P2PGossipSync_add_chain_access(this_arg: bigint, chain_access: bigint): void {
32223 if(!isWasmInitialized) {
32224 throw new Error("initializeWasm() must be awaited first!");
32226 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
32227 // debug statements here
32229 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
32231 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
32232 if(!isWasmInitialized) {
32233 throw new Error("initializeWasm() must be awaited first!");
32235 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
32236 // debug statements here
32238 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
32240 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
32241 if(!isWasmInitialized) {
32242 throw new Error("initializeWasm() must be awaited first!");
32244 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
32245 return nativeResponseValue;
32247 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
32249 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
32250 if(!isWasmInitialized) {
32251 throw new Error("initializeWasm() must be awaited first!");
32253 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
32254 return nativeResponseValue;
32256 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
32258 export function ChannelUpdateInfo_free(this_obj: bigint): void {
32259 if(!isWasmInitialized) {
32260 throw new Error("initializeWasm() must be awaited first!");
32262 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
32263 // debug statements here
32265 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32267 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
32268 if(!isWasmInitialized) {
32269 throw new Error("initializeWasm() must be awaited first!");
32271 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
32272 return nativeResponseValue;
32274 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
32276 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
32277 if(!isWasmInitialized) {
32278 throw new Error("initializeWasm() must be awaited first!");
32280 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
32281 // debug statements here
32283 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32285 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
32286 if(!isWasmInitialized) {
32287 throw new Error("initializeWasm() must be awaited first!");
32289 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
32290 return nativeResponseValue;
32292 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
32294 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
32295 if(!isWasmInitialized) {
32296 throw new Error("initializeWasm() must be awaited first!");
32298 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
32299 // debug statements here
32301 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32303 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
32304 if(!isWasmInitialized) {
32305 throw new Error("initializeWasm() must be awaited first!");
32307 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
32308 return nativeResponseValue;
32310 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
32312 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32313 if(!isWasmInitialized) {
32314 throw new Error("initializeWasm() must be awaited first!");
32316 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
32317 // debug statements here
32319 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32321 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
32322 if(!isWasmInitialized) {
32323 throw new Error("initializeWasm() must be awaited first!");
32325 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
32326 return nativeResponseValue;
32328 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
32330 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
32331 if(!isWasmInitialized) {
32332 throw new Error("initializeWasm() must be awaited first!");
32334 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
32335 // debug statements here
32337 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32339 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
32340 if(!isWasmInitialized) {
32341 throw new Error("initializeWasm() must be awaited first!");
32343 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
32344 return nativeResponseValue;
32346 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
32348 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
32349 if(!isWasmInitialized) {
32350 throw new Error("initializeWasm() must be awaited first!");
32352 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
32353 // debug statements here
32355 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32357 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
32358 if(!isWasmInitialized) {
32359 throw new Error("initializeWasm() must be awaited first!");
32361 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
32362 return nativeResponseValue;
32364 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
32366 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
32367 if(!isWasmInitialized) {
32368 throw new Error("initializeWasm() must be awaited first!");
32370 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
32371 // debug statements here
32373 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
32375 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
32376 if(!isWasmInitialized) {
32377 throw new Error("initializeWasm() must be awaited first!");
32379 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
32380 return nativeResponseValue;
32382 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
32384 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
32385 if(!isWasmInitialized) {
32386 throw new Error("initializeWasm() must be awaited first!");
32388 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
32389 // debug statements here
32391 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
32393 export function ChannelUpdateInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fees_arg: bigint, last_update_message_arg: bigint): bigint {
32394 if(!isWasmInitialized) {
32395 throw new Error("initializeWasm() must be awaited first!");
32397 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);
32398 return nativeResponseValue;
32400 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
32402 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
32403 if(!isWasmInitialized) {
32404 throw new Error("initializeWasm() must be awaited first!");
32406 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
32407 return nativeResponseValue;
32409 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
32411 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
32412 if(!isWasmInitialized) {
32413 throw new Error("initializeWasm() must be awaited first!");
32415 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
32416 return nativeResponseValue;
32418 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
32420 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
32421 if(!isWasmInitialized) {
32422 throw new Error("initializeWasm() must be awaited first!");
32424 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
32425 return nativeResponseValue;
32427 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
32429 export function ChannelUpdateInfo_write(obj: bigint): number {
32430 if(!isWasmInitialized) {
32431 throw new Error("initializeWasm() must be awaited first!");
32433 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
32434 return nativeResponseValue;
32436 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
32438 export function ChannelUpdateInfo_read(ser: number): bigint {
32439 if(!isWasmInitialized) {
32440 throw new Error("initializeWasm() must be awaited first!");
32442 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
32443 return nativeResponseValue;
32445 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
32447 export function ChannelInfo_free(this_obj: bigint): void {
32448 if(!isWasmInitialized) {
32449 throw new Error("initializeWasm() must be awaited first!");
32451 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
32452 // debug statements here
32454 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32456 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
32457 if(!isWasmInitialized) {
32458 throw new Error("initializeWasm() must be awaited first!");
32460 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
32461 return nativeResponseValue;
32463 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
32465 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
32466 if(!isWasmInitialized) {
32467 throw new Error("initializeWasm() must be awaited first!");
32469 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
32470 // debug statements here
32472 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32474 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
32475 if(!isWasmInitialized) {
32476 throw new Error("initializeWasm() must be awaited first!");
32478 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
32479 return nativeResponseValue;
32481 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
32483 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
32484 if(!isWasmInitialized) {
32485 throw new Error("initializeWasm() must be awaited first!");
32487 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
32488 // debug statements here
32490 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32492 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
32493 if(!isWasmInitialized) {
32494 throw new Error("initializeWasm() must be awaited first!");
32496 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
32497 return nativeResponseValue;
32499 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
32501 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
32502 if(!isWasmInitialized) {
32503 throw new Error("initializeWasm() must be awaited first!");
32505 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
32506 // debug statements here
32508 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32510 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
32511 if(!isWasmInitialized) {
32512 throw new Error("initializeWasm() must be awaited first!");
32514 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
32515 return nativeResponseValue;
32517 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
32519 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
32520 if(!isWasmInitialized) {
32521 throw new Error("initializeWasm() must be awaited first!");
32523 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
32524 // debug statements here
32526 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32528 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
32529 if(!isWasmInitialized) {
32530 throw new Error("initializeWasm() must be awaited first!");
32532 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
32533 return nativeResponseValue;
32535 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
32537 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
32538 if(!isWasmInitialized) {
32539 throw new Error("initializeWasm() must be awaited first!");
32541 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
32542 // debug statements here
32544 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32546 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
32547 if(!isWasmInitialized) {
32548 throw new Error("initializeWasm() must be awaited first!");
32550 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
32551 return nativeResponseValue;
32553 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32555 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
32556 if(!isWasmInitialized) {
32557 throw new Error("initializeWasm() must be awaited first!");
32559 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
32560 // debug statements here
32562 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
32564 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
32565 if(!isWasmInitialized) {
32566 throw new Error("initializeWasm() must be awaited first!");
32568 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
32569 return nativeResponseValue;
32571 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
32573 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
32574 if(!isWasmInitialized) {
32575 throw new Error("initializeWasm() must be awaited first!");
32577 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
32578 // debug statements here
32580 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
32582 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
32583 if(!isWasmInitialized) {
32584 throw new Error("initializeWasm() must be awaited first!");
32586 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
32587 return nativeResponseValue;
32589 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
32591 export function ChannelInfo_clone(orig: bigint): bigint {
32592 if(!isWasmInitialized) {
32593 throw new Error("initializeWasm() must be awaited first!");
32595 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
32596 return nativeResponseValue;
32598 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
32600 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
32601 if(!isWasmInitialized) {
32602 throw new Error("initializeWasm() must be awaited first!");
32604 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
32605 return nativeResponseValue;
32607 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
32609 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
32610 if(!isWasmInitialized) {
32611 throw new Error("initializeWasm() must be awaited first!");
32613 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
32614 return nativeResponseValue;
32616 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
32618 export function ChannelInfo_write(obj: bigint): number {
32619 if(!isWasmInitialized) {
32620 throw new Error("initializeWasm() must be awaited first!");
32622 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
32623 return nativeResponseValue;
32625 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
32627 export function ChannelInfo_read(ser: number): bigint {
32628 if(!isWasmInitialized) {
32629 throw new Error("initializeWasm() must be awaited first!");
32631 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
32632 return nativeResponseValue;
32634 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
32636 export function DirectedChannelInfo_free(this_obj: bigint): void {
32637 if(!isWasmInitialized) {
32638 throw new Error("initializeWasm() must be awaited first!");
32640 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
32641 // debug statements here
32643 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
32645 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
32646 if(!isWasmInitialized) {
32647 throw new Error("initializeWasm() must be awaited first!");
32649 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
32650 return nativeResponseValue;
32652 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
32654 export function DirectedChannelInfo_clone(orig: bigint): bigint {
32655 if(!isWasmInitialized) {
32656 throw new Error("initializeWasm() must be awaited first!");
32658 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
32659 return nativeResponseValue;
32661 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
32663 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
32664 if(!isWasmInitialized) {
32665 throw new Error("initializeWasm() must be awaited first!");
32667 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
32668 return nativeResponseValue;
32670 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
32672 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
32673 if(!isWasmInitialized) {
32674 throw new Error("initializeWasm() must be awaited first!");
32676 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
32677 return nativeResponseValue;
32679 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
32681 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
32682 if(!isWasmInitialized) {
32683 throw new Error("initializeWasm() must be awaited first!");
32685 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
32686 return nativeResponseValue;
32688 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
32690 export function EffectiveCapacity_free(this_ptr: bigint): void {
32691 if(!isWasmInitialized) {
32692 throw new Error("initializeWasm() must be awaited first!");
32694 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
32695 // debug statements here
32697 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
32699 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
32700 if(!isWasmInitialized) {
32701 throw new Error("initializeWasm() must be awaited first!");
32703 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
32704 return nativeResponseValue;
32706 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
32708 export function EffectiveCapacity_clone(orig: bigint): bigint {
32709 if(!isWasmInitialized) {
32710 throw new Error("initializeWasm() must be awaited first!");
32712 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
32713 return nativeResponseValue;
32715 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
32717 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
32718 if(!isWasmInitialized) {
32719 throw new Error("initializeWasm() must be awaited first!");
32721 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
32722 return nativeResponseValue;
32724 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
32726 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
32727 if(!isWasmInitialized) {
32728 throw new Error("initializeWasm() must be awaited first!");
32730 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
32731 return nativeResponseValue;
32733 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
32735 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
32736 if(!isWasmInitialized) {
32737 throw new Error("initializeWasm() must be awaited first!");
32739 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
32740 return nativeResponseValue;
32742 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
32744 export function EffectiveCapacity_infinite(): bigint {
32745 if(!isWasmInitialized) {
32746 throw new Error("initializeWasm() must be awaited first!");
32748 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
32749 return nativeResponseValue;
32751 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
32753 export function EffectiveCapacity_unknown(): bigint {
32754 if(!isWasmInitialized) {
32755 throw new Error("initializeWasm() must be awaited first!");
32757 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
32758 return nativeResponseValue;
32760 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
32762 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
32763 if(!isWasmInitialized) {
32764 throw new Error("initializeWasm() must be awaited first!");
32766 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
32767 return nativeResponseValue;
32769 // void RoutingFees_free(struct LDKRoutingFees this_obj);
32771 export function RoutingFees_free(this_obj: bigint): void {
32772 if(!isWasmInitialized) {
32773 throw new Error("initializeWasm() must be awaited first!");
32775 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
32776 // debug statements here
32778 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
32780 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
32781 if(!isWasmInitialized) {
32782 throw new Error("initializeWasm() must be awaited first!");
32784 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
32785 return nativeResponseValue;
32787 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
32789 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
32790 if(!isWasmInitialized) {
32791 throw new Error("initializeWasm() must be awaited first!");
32793 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
32794 // debug statements here
32796 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
32798 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
32799 if(!isWasmInitialized) {
32800 throw new Error("initializeWasm() must be awaited first!");
32802 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
32803 return nativeResponseValue;
32805 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
32807 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
32808 if(!isWasmInitialized) {
32809 throw new Error("initializeWasm() must be awaited first!");
32811 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
32812 // debug statements here
32814 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
32816 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
32817 if(!isWasmInitialized) {
32818 throw new Error("initializeWasm() must be awaited first!");
32820 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
32821 return nativeResponseValue;
32823 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
32825 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
32826 if(!isWasmInitialized) {
32827 throw new Error("initializeWasm() must be awaited first!");
32829 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
32830 return nativeResponseValue;
32832 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
32834 export function RoutingFees_clone_ptr(arg: bigint): bigint {
32835 if(!isWasmInitialized) {
32836 throw new Error("initializeWasm() must be awaited first!");
32838 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
32839 return nativeResponseValue;
32841 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
32843 export function RoutingFees_clone(orig: bigint): bigint {
32844 if(!isWasmInitialized) {
32845 throw new Error("initializeWasm() must be awaited first!");
32847 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
32848 return nativeResponseValue;
32850 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
32852 export function RoutingFees_hash(o: bigint): bigint {
32853 if(!isWasmInitialized) {
32854 throw new Error("initializeWasm() must be awaited first!");
32856 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
32857 return nativeResponseValue;
32859 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
32861 export function RoutingFees_write(obj: bigint): number {
32862 if(!isWasmInitialized) {
32863 throw new Error("initializeWasm() must be awaited first!");
32865 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
32866 return nativeResponseValue;
32868 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
32870 export function RoutingFees_read(ser: number): bigint {
32871 if(!isWasmInitialized) {
32872 throw new Error("initializeWasm() must be awaited first!");
32874 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
32875 return nativeResponseValue;
32877 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
32879 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
32880 if(!isWasmInitialized) {
32881 throw new Error("initializeWasm() must be awaited first!");
32883 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
32884 // debug statements here
32886 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
32888 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
32889 if(!isWasmInitialized) {
32890 throw new Error("initializeWasm() must be awaited first!");
32892 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
32893 return nativeResponseValue;
32895 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
32897 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
32898 if(!isWasmInitialized) {
32899 throw new Error("initializeWasm() must be awaited first!");
32901 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
32902 // debug statements here
32904 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
32906 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
32907 if(!isWasmInitialized) {
32908 throw new Error("initializeWasm() must be awaited first!");
32910 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
32911 return nativeResponseValue;
32913 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
32915 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
32916 if(!isWasmInitialized) {
32917 throw new Error("initializeWasm() must be awaited first!");
32919 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
32920 // debug statements here
32922 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
32924 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
32925 if(!isWasmInitialized) {
32926 throw new Error("initializeWasm() must be awaited first!");
32928 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
32929 return nativeResponseValue;
32931 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
32933 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
32934 if(!isWasmInitialized) {
32935 throw new Error("initializeWasm() must be awaited first!");
32937 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
32938 // debug statements here
32940 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
32942 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
32943 if(!isWasmInitialized) {
32944 throw new Error("initializeWasm() must be awaited first!");
32946 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
32947 return nativeResponseValue;
32949 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
32951 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
32952 if(!isWasmInitialized) {
32953 throw new Error("initializeWasm() must be awaited first!");
32955 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
32956 // debug statements here
32958 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
32960 export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
32961 if(!isWasmInitialized) {
32962 throw new Error("initializeWasm() must be awaited first!");
32964 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
32965 return nativeResponseValue;
32967 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
32969 export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
32970 if(!isWasmInitialized) {
32971 throw new Error("initializeWasm() must be awaited first!");
32973 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
32974 // debug statements here
32976 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
32978 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
32979 if(!isWasmInitialized) {
32980 throw new Error("initializeWasm() must be awaited first!");
32982 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
32983 return nativeResponseValue;
32985 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
32987 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
32988 if(!isWasmInitialized) {
32989 throw new Error("initializeWasm() must be awaited first!");
32991 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
32992 // debug statements here
32994 // 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);
32996 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, addresses_arg: number, announcement_message_arg: bigint): bigint {
32997 if(!isWasmInitialized) {
32998 throw new Error("initializeWasm() must be awaited first!");
33000 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
33001 return nativeResponseValue;
33003 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
33005 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
33006 if(!isWasmInitialized) {
33007 throw new Error("initializeWasm() must be awaited first!");
33009 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
33010 return nativeResponseValue;
33012 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
33014 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
33015 if(!isWasmInitialized) {
33016 throw new Error("initializeWasm() must be awaited first!");
33018 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
33019 return nativeResponseValue;
33021 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
33023 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
33024 if(!isWasmInitialized) {
33025 throw new Error("initializeWasm() must be awaited first!");
33027 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
33028 return nativeResponseValue;
33030 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
33032 export function NodeAnnouncementInfo_write(obj: bigint): number {
33033 if(!isWasmInitialized) {
33034 throw new Error("initializeWasm() must be awaited first!");
33036 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
33037 return nativeResponseValue;
33039 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
33041 export function NodeAnnouncementInfo_read(ser: number): bigint {
33042 if(!isWasmInitialized) {
33043 throw new Error("initializeWasm() must be awaited first!");
33045 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
33046 return nativeResponseValue;
33048 // void NodeAlias_free(struct LDKNodeAlias this_obj);
33050 export function NodeAlias_free(this_obj: bigint): void {
33051 if(!isWasmInitialized) {
33052 throw new Error("initializeWasm() must be awaited first!");
33054 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
33055 // debug statements here
33057 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
33059 export function NodeAlias_get_a(this_ptr: bigint): number {
33060 if(!isWasmInitialized) {
33061 throw new Error("initializeWasm() must be awaited first!");
33063 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
33064 return nativeResponseValue;
33066 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33068 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
33069 if(!isWasmInitialized) {
33070 throw new Error("initializeWasm() must be awaited first!");
33072 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
33073 // debug statements here
33075 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
33077 export function NodeAlias_new(a_arg: number): bigint {
33078 if(!isWasmInitialized) {
33079 throw new Error("initializeWasm() must be awaited first!");
33081 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
33082 return nativeResponseValue;
33084 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
33086 export function NodeAlias_clone_ptr(arg: bigint): bigint {
33087 if(!isWasmInitialized) {
33088 throw new Error("initializeWasm() must be awaited first!");
33090 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
33091 return nativeResponseValue;
33093 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
33095 export function NodeAlias_clone(orig: bigint): bigint {
33096 if(!isWasmInitialized) {
33097 throw new Error("initializeWasm() must be awaited first!");
33099 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
33100 return nativeResponseValue;
33102 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
33104 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
33105 if(!isWasmInitialized) {
33106 throw new Error("initializeWasm() must be awaited first!");
33108 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
33109 return nativeResponseValue;
33111 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
33113 export function NodeAlias_write(obj: bigint): number {
33114 if(!isWasmInitialized) {
33115 throw new Error("initializeWasm() must be awaited first!");
33117 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
33118 return nativeResponseValue;
33120 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
33122 export function NodeAlias_read(ser: number): bigint {
33123 if(!isWasmInitialized) {
33124 throw new Error("initializeWasm() must be awaited first!");
33126 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
33127 return nativeResponseValue;
33129 // void NodeInfo_free(struct LDKNodeInfo this_obj);
33131 export function NodeInfo_free(this_obj: bigint): void {
33132 if(!isWasmInitialized) {
33133 throw new Error("initializeWasm() must be awaited first!");
33135 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
33136 // debug statements here
33138 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
33140 export function NodeInfo_get_channels(this_ptr: bigint): number {
33141 if(!isWasmInitialized) {
33142 throw new Error("initializeWasm() must be awaited first!");
33144 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
33145 return nativeResponseValue;
33147 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
33149 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
33150 if(!isWasmInitialized) {
33151 throw new Error("initializeWasm() must be awaited first!");
33153 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
33154 // debug statements here
33156 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
33158 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: bigint): bigint {
33159 if(!isWasmInitialized) {
33160 throw new Error("initializeWasm() must be awaited first!");
33162 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
33163 return nativeResponseValue;
33165 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
33167 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: bigint, val: bigint): void {
33168 if(!isWasmInitialized) {
33169 throw new Error("initializeWasm() must be awaited first!");
33171 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
33172 // debug statements here
33174 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
33176 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
33177 if(!isWasmInitialized) {
33178 throw new Error("initializeWasm() must be awaited first!");
33180 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
33181 return nativeResponseValue;
33183 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
33185 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
33186 if(!isWasmInitialized) {
33187 throw new Error("initializeWasm() must be awaited first!");
33189 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
33190 // debug statements here
33192 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
33194 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: bigint, announcement_info_arg: bigint): bigint {
33195 if(!isWasmInitialized) {
33196 throw new Error("initializeWasm() must be awaited first!");
33198 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
33199 return nativeResponseValue;
33201 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
33203 export function NodeInfo_clone_ptr(arg: bigint): bigint {
33204 if(!isWasmInitialized) {
33205 throw new Error("initializeWasm() must be awaited first!");
33207 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
33208 return nativeResponseValue;
33210 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
33212 export function NodeInfo_clone(orig: bigint): bigint {
33213 if(!isWasmInitialized) {
33214 throw new Error("initializeWasm() must be awaited first!");
33216 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
33217 return nativeResponseValue;
33219 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
33221 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
33222 if(!isWasmInitialized) {
33223 throw new Error("initializeWasm() must be awaited first!");
33225 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
33226 return nativeResponseValue;
33228 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
33230 export function NodeInfo_write(obj: bigint): number {
33231 if(!isWasmInitialized) {
33232 throw new Error("initializeWasm() must be awaited first!");
33234 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
33235 return nativeResponseValue;
33237 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
33239 export function NodeInfo_read(ser: number): bigint {
33240 if(!isWasmInitialized) {
33241 throw new Error("initializeWasm() must be awaited first!");
33243 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
33244 return nativeResponseValue;
33246 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
33248 export function NetworkGraph_write(obj: bigint): number {
33249 if(!isWasmInitialized) {
33250 throw new Error("initializeWasm() must be awaited first!");
33252 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
33253 return nativeResponseValue;
33255 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
33257 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
33258 if(!isWasmInitialized) {
33259 throw new Error("initializeWasm() must be awaited first!");
33261 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
33262 return nativeResponseValue;
33264 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
33266 export function NetworkGraph_new(genesis_hash: number, logger: bigint): bigint {
33267 if(!isWasmInitialized) {
33268 throw new Error("initializeWasm() must be awaited first!");
33270 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
33271 return nativeResponseValue;
33273 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
33275 export function NetworkGraph_read_only(this_arg: bigint): bigint {
33276 if(!isWasmInitialized) {
33277 throw new Error("initializeWasm() must be awaited first!");
33279 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
33280 return nativeResponseValue;
33282 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
33284 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
33285 if(!isWasmInitialized) {
33286 throw new Error("initializeWasm() must be awaited first!");
33288 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
33289 return nativeResponseValue;
33291 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
33293 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
33294 if(!isWasmInitialized) {
33295 throw new Error("initializeWasm() must be awaited first!");
33297 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
33298 // debug statements here
33300 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
33302 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
33303 if(!isWasmInitialized) {
33304 throw new Error("initializeWasm() must be awaited first!");
33306 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
33307 return nativeResponseValue;
33309 // 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);
33311 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
33312 if(!isWasmInitialized) {
33313 throw new Error("initializeWasm() must be awaited first!");
33315 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
33316 return nativeResponseValue;
33318 // 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);
33320 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
33321 if(!isWasmInitialized) {
33322 throw new Error("initializeWasm() must be awaited first!");
33324 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
33325 return nativeResponseValue;
33327 // 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);
33329 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
33330 if(!isWasmInitialized) {
33331 throw new Error("initializeWasm() must be awaited first!");
33333 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
33334 return nativeResponseValue;
33336 // 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);
33338 export function NetworkGraph_add_channel_from_partial_announcement(this_arg: bigint, short_channel_id: bigint, timestamp: bigint, features: bigint, node_id_1: number, node_id_2: number): bigint {
33339 if(!isWasmInitialized) {
33340 throw new Error("initializeWasm() must be awaited first!");
33342 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
33343 return nativeResponseValue;
33345 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
33347 export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
33348 if(!isWasmInitialized) {
33349 throw new Error("initializeWasm() must be awaited first!");
33351 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
33352 // debug statements here
33354 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
33356 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
33357 if(!isWasmInitialized) {
33358 throw new Error("initializeWasm() must be awaited first!");
33360 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
33361 // debug statements here
33363 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
33365 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
33366 if(!isWasmInitialized) {
33367 throw new Error("initializeWasm() must be awaited first!");
33369 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
33370 // debug statements here
33372 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
33374 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
33375 if(!isWasmInitialized) {
33376 throw new Error("initializeWasm() must be awaited first!");
33378 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
33379 return nativeResponseValue;
33381 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
33383 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
33384 if(!isWasmInitialized) {
33385 throw new Error("initializeWasm() must be awaited first!");
33387 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
33388 return nativeResponseValue;
33390 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
33392 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
33393 if(!isWasmInitialized) {
33394 throw new Error("initializeWasm() must be awaited first!");
33396 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
33397 return nativeResponseValue;
33399 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
33401 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
33402 if(!isWasmInitialized) {
33403 throw new Error("initializeWasm() must be awaited first!");
33405 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
33406 return nativeResponseValue;
33408 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
33410 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
33411 if(!isWasmInitialized) {
33412 throw new Error("initializeWasm() must be awaited first!");
33414 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
33415 return nativeResponseValue;
33417 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
33419 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
33420 if(!isWasmInitialized) {
33421 throw new Error("initializeWasm() must be awaited first!");
33423 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
33424 return nativeResponseValue;
33426 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
33428 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
33429 if(!isWasmInitialized) {
33430 throw new Error("initializeWasm() must be awaited first!");
33432 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
33433 return nativeResponseValue;
33435 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
33437 export function DefaultRouter_free(this_obj: bigint): void {
33438 if(!isWasmInitialized) {
33439 throw new Error("initializeWasm() must be awaited first!");
33441 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
33442 // debug statements here
33444 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes, struct LDKLockableScore scorer);
33446 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
33447 if(!isWasmInitialized) {
33448 throw new Error("initializeWasm() must be awaited first!");
33450 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
33451 return nativeResponseValue;
33453 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
33455 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
33456 if(!isWasmInitialized) {
33457 throw new Error("initializeWasm() must be awaited first!");
33459 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
33460 return nativeResponseValue;
33462 // void Router_free(struct LDKRouter this_ptr);
33464 export function Router_free(this_ptr: bigint): void {
33465 if(!isWasmInitialized) {
33466 throw new Error("initializeWasm() must be awaited first!");
33468 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
33469 // debug statements here
33471 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
33473 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
33474 if(!isWasmInitialized) {
33475 throw new Error("initializeWasm() must be awaited first!");
33477 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
33478 // debug statements here
33480 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScore scorer, struct LDKInFlightHtlcs inflight_htlcs);
33482 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
33483 if(!isWasmInitialized) {
33484 throw new Error("initializeWasm() must be awaited first!");
33486 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
33487 return nativeResponseValue;
33489 // struct LDKCVec_u8Z ScorerAccountingForInFlightHtlcs_write(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR obj);
33491 export function ScorerAccountingForInFlightHtlcs_write(obj: bigint): number {
33492 if(!isWasmInitialized) {
33493 throw new Error("initializeWasm() must be awaited first!");
33495 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_write(obj);
33496 return nativeResponseValue;
33498 // struct LDKScore ScorerAccountingForInFlightHtlcs_as_Score(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
33500 export function ScorerAccountingForInFlightHtlcs_as_Score(this_arg: bigint): bigint {
33501 if(!isWasmInitialized) {
33502 throw new Error("initializeWasm() must be awaited first!");
33504 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_Score(this_arg);
33505 return nativeResponseValue;
33507 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
33509 export function InFlightHtlcs_free(this_obj: bigint): void {
33510 if(!isWasmInitialized) {
33511 throw new Error("initializeWasm() must be awaited first!");
33513 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
33514 // debug statements here
33516 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
33518 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
33519 if(!isWasmInitialized) {
33520 throw new Error("initializeWasm() must be awaited first!");
33522 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
33523 return nativeResponseValue;
33525 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
33527 export function InFlightHtlcs_clone(orig: bigint): bigint {
33528 if(!isWasmInitialized) {
33529 throw new Error("initializeWasm() must be awaited first!");
33531 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
33532 return nativeResponseValue;
33534 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
33536 export function InFlightHtlcs_new(): bigint {
33537 if(!isWasmInitialized) {
33538 throw new Error("initializeWasm() must be awaited first!");
33540 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
33541 return nativeResponseValue;
33543 // MUST_USE_RES struct LDKCOption_u64Z InFlightHtlcs_used_liquidity_msat(const struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid);
33545 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
33546 if(!isWasmInitialized) {
33547 throw new Error("initializeWasm() must be awaited first!");
33549 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
33550 return nativeResponseValue;
33552 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
33554 export function InFlightHtlcs_write(obj: bigint): number {
33555 if(!isWasmInitialized) {
33556 throw new Error("initializeWasm() must be awaited first!");
33558 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
33559 return nativeResponseValue;
33561 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
33563 export function InFlightHtlcs_read(ser: number): bigint {
33564 if(!isWasmInitialized) {
33565 throw new Error("initializeWasm() must be awaited first!");
33567 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
33568 return nativeResponseValue;
33570 // void RouteHop_free(struct LDKRouteHop this_obj);
33572 export function RouteHop_free(this_obj: bigint): void {
33573 if(!isWasmInitialized) {
33574 throw new Error("initializeWasm() must be awaited first!");
33576 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
33577 // debug statements here
33579 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33581 export function RouteHop_get_pubkey(this_ptr: bigint): number {
33582 if(!isWasmInitialized) {
33583 throw new Error("initializeWasm() must be awaited first!");
33585 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
33586 return nativeResponseValue;
33588 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33590 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
33591 if(!isWasmInitialized) {
33592 throw new Error("initializeWasm() must be awaited first!");
33594 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
33595 // debug statements here
33597 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33599 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
33600 if(!isWasmInitialized) {
33601 throw new Error("initializeWasm() must be awaited first!");
33603 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
33604 return nativeResponseValue;
33606 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
33608 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
33609 if(!isWasmInitialized) {
33610 throw new Error("initializeWasm() must be awaited first!");
33612 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
33613 // debug statements here
33615 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33617 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
33618 if(!isWasmInitialized) {
33619 throw new Error("initializeWasm() must be awaited first!");
33621 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
33622 return nativeResponseValue;
33624 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
33626 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
33627 if(!isWasmInitialized) {
33628 throw new Error("initializeWasm() must be awaited first!");
33630 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
33631 // debug statements here
33633 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33635 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
33636 if(!isWasmInitialized) {
33637 throw new Error("initializeWasm() must be awaited first!");
33639 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
33640 return nativeResponseValue;
33642 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
33644 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
33645 if(!isWasmInitialized) {
33646 throw new Error("initializeWasm() must be awaited first!");
33648 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
33649 // debug statements here
33651 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33653 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
33654 if(!isWasmInitialized) {
33655 throw new Error("initializeWasm() must be awaited first!");
33657 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
33658 return nativeResponseValue;
33660 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
33662 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
33663 if(!isWasmInitialized) {
33664 throw new Error("initializeWasm() must be awaited first!");
33666 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
33667 // debug statements here
33669 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
33671 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
33672 if(!isWasmInitialized) {
33673 throw new Error("initializeWasm() must be awaited first!");
33675 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
33676 return nativeResponseValue;
33678 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
33680 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
33681 if(!isWasmInitialized) {
33682 throw new Error("initializeWasm() must be awaited first!");
33684 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
33685 // debug statements here
33687 // 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);
33689 export function RouteHop_new(pubkey_arg: number, node_features_arg: bigint, short_channel_id_arg: bigint, channel_features_arg: bigint, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): bigint {
33690 if(!isWasmInitialized) {
33691 throw new Error("initializeWasm() must be awaited first!");
33693 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);
33694 return nativeResponseValue;
33696 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
33698 export function RouteHop_clone_ptr(arg: bigint): bigint {
33699 if(!isWasmInitialized) {
33700 throw new Error("initializeWasm() must be awaited first!");
33702 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
33703 return nativeResponseValue;
33705 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
33707 export function RouteHop_clone(orig: bigint): bigint {
33708 if(!isWasmInitialized) {
33709 throw new Error("initializeWasm() must be awaited first!");
33711 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
33712 return nativeResponseValue;
33714 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
33716 export function RouteHop_hash(o: bigint): bigint {
33717 if(!isWasmInitialized) {
33718 throw new Error("initializeWasm() must be awaited first!");
33720 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
33721 return nativeResponseValue;
33723 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
33725 export function RouteHop_eq(a: bigint, b: bigint): boolean {
33726 if(!isWasmInitialized) {
33727 throw new Error("initializeWasm() must be awaited first!");
33729 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
33730 return nativeResponseValue;
33732 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
33734 export function RouteHop_write(obj: bigint): number {
33735 if(!isWasmInitialized) {
33736 throw new Error("initializeWasm() must be awaited first!");
33738 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
33739 return nativeResponseValue;
33741 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
33743 export function RouteHop_read(ser: number): bigint {
33744 if(!isWasmInitialized) {
33745 throw new Error("initializeWasm() must be awaited first!");
33747 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
33748 return nativeResponseValue;
33750 // void Route_free(struct LDKRoute this_obj);
33752 export function Route_free(this_obj: bigint): void {
33753 if(!isWasmInitialized) {
33754 throw new Error("initializeWasm() must be awaited first!");
33756 const nativeResponseValue = wasm.TS_Route_free(this_obj);
33757 // debug statements here
33759 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
33761 export function Route_get_paths(this_ptr: bigint): number {
33762 if(!isWasmInitialized) {
33763 throw new Error("initializeWasm() must be awaited first!");
33765 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
33766 return nativeResponseValue;
33768 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
33770 export function Route_set_paths(this_ptr: bigint, val: number): void {
33771 if(!isWasmInitialized) {
33772 throw new Error("initializeWasm() must be awaited first!");
33774 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
33775 // debug statements here
33777 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
33779 export function Route_get_payment_params(this_ptr: bigint): bigint {
33780 if(!isWasmInitialized) {
33781 throw new Error("initializeWasm() must be awaited first!");
33783 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
33784 return nativeResponseValue;
33786 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
33788 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
33789 if(!isWasmInitialized) {
33790 throw new Error("initializeWasm() must be awaited first!");
33792 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
33793 // debug statements here
33795 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
33797 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
33798 if(!isWasmInitialized) {
33799 throw new Error("initializeWasm() must be awaited first!");
33801 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
33802 return nativeResponseValue;
33804 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
33806 export function Route_clone_ptr(arg: bigint): bigint {
33807 if(!isWasmInitialized) {
33808 throw new Error("initializeWasm() must be awaited first!");
33810 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
33811 return nativeResponseValue;
33813 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
33815 export function Route_clone(orig: bigint): bigint {
33816 if(!isWasmInitialized) {
33817 throw new Error("initializeWasm() must be awaited first!");
33819 const nativeResponseValue = wasm.TS_Route_clone(orig);
33820 return nativeResponseValue;
33822 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
33824 export function Route_hash(o: bigint): bigint {
33825 if(!isWasmInitialized) {
33826 throw new Error("initializeWasm() must be awaited first!");
33828 const nativeResponseValue = wasm.TS_Route_hash(o);
33829 return nativeResponseValue;
33831 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
33833 export function Route_eq(a: bigint, b: bigint): boolean {
33834 if(!isWasmInitialized) {
33835 throw new Error("initializeWasm() must be awaited first!");
33837 const nativeResponseValue = wasm.TS_Route_eq(a, b);
33838 return nativeResponseValue;
33840 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
33842 export function Route_get_total_fees(this_arg: bigint): bigint {
33843 if(!isWasmInitialized) {
33844 throw new Error("initializeWasm() must be awaited first!");
33846 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
33847 return nativeResponseValue;
33849 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
33851 export function Route_get_total_amount(this_arg: bigint): bigint {
33852 if(!isWasmInitialized) {
33853 throw new Error("initializeWasm() must be awaited first!");
33855 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
33856 return nativeResponseValue;
33858 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
33860 export function Route_write(obj: bigint): number {
33861 if(!isWasmInitialized) {
33862 throw new Error("initializeWasm() must be awaited first!");
33864 const nativeResponseValue = wasm.TS_Route_write(obj);
33865 return nativeResponseValue;
33867 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
33869 export function Route_read(ser: number): bigint {
33870 if(!isWasmInitialized) {
33871 throw new Error("initializeWasm() must be awaited first!");
33873 const nativeResponseValue = wasm.TS_Route_read(ser);
33874 return nativeResponseValue;
33876 // void RouteParameters_free(struct LDKRouteParameters this_obj);
33878 export function RouteParameters_free(this_obj: bigint): void {
33879 if(!isWasmInitialized) {
33880 throw new Error("initializeWasm() must be awaited first!");
33882 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
33883 // debug statements here
33885 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
33887 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
33888 if(!isWasmInitialized) {
33889 throw new Error("initializeWasm() must be awaited first!");
33891 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
33892 return nativeResponseValue;
33894 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
33896 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
33897 if(!isWasmInitialized) {
33898 throw new Error("initializeWasm() must be awaited first!");
33900 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
33901 // debug statements here
33903 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
33905 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
33906 if(!isWasmInitialized) {
33907 throw new Error("initializeWasm() must be awaited first!");
33909 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
33910 return nativeResponseValue;
33912 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
33914 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
33915 if(!isWasmInitialized) {
33916 throw new Error("initializeWasm() must be awaited first!");
33918 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
33919 // debug statements here
33921 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
33923 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
33924 if(!isWasmInitialized) {
33925 throw new Error("initializeWasm() must be awaited first!");
33927 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
33928 return nativeResponseValue;
33930 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
33932 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
33933 if(!isWasmInitialized) {
33934 throw new Error("initializeWasm() must be awaited first!");
33936 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
33937 // debug statements here
33939 // 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);
33941 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): bigint {
33942 if(!isWasmInitialized) {
33943 throw new Error("initializeWasm() must be awaited first!");
33945 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
33946 return nativeResponseValue;
33948 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
33950 export function RouteParameters_clone_ptr(arg: bigint): bigint {
33951 if(!isWasmInitialized) {
33952 throw new Error("initializeWasm() must be awaited first!");
33954 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
33955 return nativeResponseValue;
33957 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
33959 export function RouteParameters_clone(orig: bigint): bigint {
33960 if(!isWasmInitialized) {
33961 throw new Error("initializeWasm() must be awaited first!");
33963 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
33964 return nativeResponseValue;
33966 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
33968 export function RouteParameters_write(obj: bigint): number {
33969 if(!isWasmInitialized) {
33970 throw new Error("initializeWasm() must be awaited first!");
33972 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
33973 return nativeResponseValue;
33975 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
33977 export function RouteParameters_read(ser: number): bigint {
33978 if(!isWasmInitialized) {
33979 throw new Error("initializeWasm() must be awaited first!");
33981 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
33982 return nativeResponseValue;
33984 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
33986 export function PaymentParameters_free(this_obj: bigint): void {
33987 if(!isWasmInitialized) {
33988 throw new Error("initializeWasm() must be awaited first!");
33990 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
33991 // debug statements here
33993 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
33995 export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
33996 if(!isWasmInitialized) {
33997 throw new Error("initializeWasm() must be awaited first!");
33999 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
34000 return nativeResponseValue;
34002 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34004 export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
34005 if(!isWasmInitialized) {
34006 throw new Error("initializeWasm() must be awaited first!");
34008 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
34009 // debug statements here
34011 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34013 export function PaymentParameters_get_features(this_ptr: bigint): bigint {
34014 if(!isWasmInitialized) {
34015 throw new Error("initializeWasm() must be awaited first!");
34017 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
34018 return nativeResponseValue;
34020 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
34022 export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
34023 if(!isWasmInitialized) {
34024 throw new Error("initializeWasm() must be awaited first!");
34026 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
34027 // debug statements here
34029 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34031 export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
34032 if(!isWasmInitialized) {
34033 throw new Error("initializeWasm() must be awaited first!");
34035 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
34036 return nativeResponseValue;
34038 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
34040 export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
34041 if(!isWasmInitialized) {
34042 throw new Error("initializeWasm() must be awaited first!");
34044 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
34045 // debug statements here
34047 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34049 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
34050 if(!isWasmInitialized) {
34051 throw new Error("initializeWasm() must be awaited first!");
34053 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
34054 return nativeResponseValue;
34056 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
34058 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
34059 if(!isWasmInitialized) {
34060 throw new Error("initializeWasm() must be awaited first!");
34062 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
34063 // debug statements here
34065 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34067 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
34068 if(!isWasmInitialized) {
34069 throw new Error("initializeWasm() must be awaited first!");
34071 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
34072 return nativeResponseValue;
34074 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
34076 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
34077 if(!isWasmInitialized) {
34078 throw new Error("initializeWasm() must be awaited first!");
34080 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
34081 // debug statements here
34083 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34085 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
34086 if(!isWasmInitialized) {
34087 throw new Error("initializeWasm() must be awaited first!");
34089 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
34090 return nativeResponseValue;
34092 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
34094 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
34095 if(!isWasmInitialized) {
34096 throw new Error("initializeWasm() must be awaited first!");
34098 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
34099 // debug statements here
34101 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34103 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
34104 if(!isWasmInitialized) {
34105 throw new Error("initializeWasm() must be awaited first!");
34107 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
34108 return nativeResponseValue;
34110 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
34112 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
34113 if(!isWasmInitialized) {
34114 throw new Error("initializeWasm() must be awaited first!");
34116 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
34117 // debug statements here
34119 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
34121 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
34122 if(!isWasmInitialized) {
34123 throw new Error("initializeWasm() must be awaited first!");
34125 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
34126 return nativeResponseValue;
34128 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
34130 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
34131 if(!isWasmInitialized) {
34132 throw new Error("initializeWasm() must be awaited first!");
34134 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
34135 // debug statements here
34137 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg);
34139 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: bigint, route_hints_arg: number, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number): bigint {
34140 if(!isWasmInitialized) {
34141 throw new Error("initializeWasm() must be awaited first!");
34143 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg);
34144 return nativeResponseValue;
34146 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
34148 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
34149 if(!isWasmInitialized) {
34150 throw new Error("initializeWasm() must be awaited first!");
34152 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
34153 return nativeResponseValue;
34155 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
34157 export function PaymentParameters_clone(orig: bigint): bigint {
34158 if(!isWasmInitialized) {
34159 throw new Error("initializeWasm() must be awaited first!");
34161 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
34162 return nativeResponseValue;
34164 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
34166 export function PaymentParameters_hash(o: bigint): bigint {
34167 if(!isWasmInitialized) {
34168 throw new Error("initializeWasm() must be awaited first!");
34170 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
34171 return nativeResponseValue;
34173 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
34175 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
34176 if(!isWasmInitialized) {
34177 throw new Error("initializeWasm() must be awaited first!");
34179 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
34180 return nativeResponseValue;
34182 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
34184 export function PaymentParameters_write(obj: bigint): number {
34185 if(!isWasmInitialized) {
34186 throw new Error("initializeWasm() must be awaited first!");
34188 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
34189 return nativeResponseValue;
34191 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
34193 export function PaymentParameters_read(ser: number): bigint {
34194 if(!isWasmInitialized) {
34195 throw new Error("initializeWasm() must be awaited first!");
34197 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
34198 return nativeResponseValue;
34200 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
34202 export function PaymentParameters_from_node_id(payee_pubkey: number): bigint {
34203 if(!isWasmInitialized) {
34204 throw new Error("initializeWasm() must be awaited first!");
34206 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
34207 return nativeResponseValue;
34209 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
34211 export function PaymentParameters_for_keysend(payee_pubkey: number): bigint {
34212 if(!isWasmInitialized) {
34213 throw new Error("initializeWasm() must be awaited first!");
34215 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
34216 return nativeResponseValue;
34218 // void RouteHint_free(struct LDKRouteHint this_obj);
34220 export function RouteHint_free(this_obj: bigint): void {
34221 if(!isWasmInitialized) {
34222 throw new Error("initializeWasm() must be awaited first!");
34224 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
34225 // debug statements here
34227 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
34229 export function RouteHint_get_a(this_ptr: bigint): number {
34230 if(!isWasmInitialized) {
34231 throw new Error("initializeWasm() must be awaited first!");
34233 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
34234 return nativeResponseValue;
34236 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
34238 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
34239 if(!isWasmInitialized) {
34240 throw new Error("initializeWasm() must be awaited first!");
34242 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
34243 // debug statements here
34245 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
34247 export function RouteHint_new(a_arg: number): bigint {
34248 if(!isWasmInitialized) {
34249 throw new Error("initializeWasm() must be awaited first!");
34251 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
34252 return nativeResponseValue;
34254 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
34256 export function RouteHint_clone_ptr(arg: bigint): bigint {
34257 if(!isWasmInitialized) {
34258 throw new Error("initializeWasm() must be awaited first!");
34260 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
34261 return nativeResponseValue;
34263 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
34265 export function RouteHint_clone(orig: bigint): bigint {
34266 if(!isWasmInitialized) {
34267 throw new Error("initializeWasm() must be awaited first!");
34269 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
34270 return nativeResponseValue;
34272 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
34274 export function RouteHint_hash(o: bigint): bigint {
34275 if(!isWasmInitialized) {
34276 throw new Error("initializeWasm() must be awaited first!");
34278 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
34279 return nativeResponseValue;
34281 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
34283 export function RouteHint_eq(a: bigint, b: bigint): boolean {
34284 if(!isWasmInitialized) {
34285 throw new Error("initializeWasm() must be awaited first!");
34287 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
34288 return nativeResponseValue;
34290 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
34292 export function RouteHint_write(obj: bigint): number {
34293 if(!isWasmInitialized) {
34294 throw new Error("initializeWasm() must be awaited first!");
34296 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
34297 return nativeResponseValue;
34299 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
34301 export function RouteHint_read(ser: number): bigint {
34302 if(!isWasmInitialized) {
34303 throw new Error("initializeWasm() must be awaited first!");
34305 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
34306 return nativeResponseValue;
34308 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
34310 export function RouteHintHop_free(this_obj: bigint): void {
34311 if(!isWasmInitialized) {
34312 throw new Error("initializeWasm() must be awaited first!");
34314 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
34315 // debug statements here
34317 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34319 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
34320 if(!isWasmInitialized) {
34321 throw new Error("initializeWasm() must be awaited first!");
34323 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
34324 return nativeResponseValue;
34326 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34328 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
34329 if(!isWasmInitialized) {
34330 throw new Error("initializeWasm() must be awaited first!");
34332 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
34333 // debug statements here
34335 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34337 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
34338 if(!isWasmInitialized) {
34339 throw new Error("initializeWasm() must be awaited first!");
34341 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
34342 return nativeResponseValue;
34344 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
34346 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
34347 if(!isWasmInitialized) {
34348 throw new Error("initializeWasm() must be awaited first!");
34350 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
34351 // debug statements here
34353 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34355 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
34356 if(!isWasmInitialized) {
34357 throw new Error("initializeWasm() must be awaited first!");
34359 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
34360 return nativeResponseValue;
34362 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
34364 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
34365 if(!isWasmInitialized) {
34366 throw new Error("initializeWasm() must be awaited first!");
34368 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
34369 // debug statements here
34371 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34373 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
34374 if(!isWasmInitialized) {
34375 throw new Error("initializeWasm() must be awaited first!");
34377 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
34378 return nativeResponseValue;
34380 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
34382 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
34383 if(!isWasmInitialized) {
34384 throw new Error("initializeWasm() must be awaited first!");
34386 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
34387 // debug statements here
34389 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34391 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
34392 if(!isWasmInitialized) {
34393 throw new Error("initializeWasm() must be awaited first!");
34395 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
34396 return nativeResponseValue;
34398 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
34400 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
34401 if(!isWasmInitialized) {
34402 throw new Error("initializeWasm() must be awaited first!");
34404 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
34405 // debug statements here
34407 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
34409 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
34410 if(!isWasmInitialized) {
34411 throw new Error("initializeWasm() must be awaited first!");
34413 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
34414 return nativeResponseValue;
34416 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
34418 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
34419 if(!isWasmInitialized) {
34420 throw new Error("initializeWasm() must be awaited first!");
34422 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
34423 // debug statements here
34425 // 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);
34427 export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: bigint, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint): bigint {
34428 if(!isWasmInitialized) {
34429 throw new Error("initializeWasm() must be awaited first!");
34431 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);
34432 return nativeResponseValue;
34434 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
34436 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
34437 if(!isWasmInitialized) {
34438 throw new Error("initializeWasm() must be awaited first!");
34440 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
34441 return nativeResponseValue;
34443 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
34445 export function RouteHintHop_clone(orig: bigint): bigint {
34446 if(!isWasmInitialized) {
34447 throw new Error("initializeWasm() must be awaited first!");
34449 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
34450 return nativeResponseValue;
34452 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
34454 export function RouteHintHop_hash(o: bigint): bigint {
34455 if(!isWasmInitialized) {
34456 throw new Error("initializeWasm() must be awaited first!");
34458 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
34459 return nativeResponseValue;
34461 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
34463 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
34464 if(!isWasmInitialized) {
34465 throw new Error("initializeWasm() must be awaited first!");
34467 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
34468 return nativeResponseValue;
34470 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
34472 export function RouteHintHop_write(obj: bigint): number {
34473 if(!isWasmInitialized) {
34474 throw new Error("initializeWasm() must be awaited first!");
34476 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
34477 return nativeResponseValue;
34479 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
34481 export function RouteHintHop_read(ser: number): bigint {
34482 if(!isWasmInitialized) {
34483 throw new Error("initializeWasm() must be awaited first!");
34485 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
34486 return nativeResponseValue;
34488 // 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]);
34490 export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, random_seed_bytes: number): bigint {
34491 if(!isWasmInitialized) {
34492 throw new Error("initializeWasm() must be awaited first!");
34494 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
34495 return nativeResponseValue;
34497 // 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]);
34499 export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: bigint, network_graph: bigint, logger: bigint, random_seed_bytes: number): bigint {
34500 if(!isWasmInitialized) {
34501 throw new Error("initializeWasm() must be awaited first!");
34503 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
34504 return nativeResponseValue;
34506 // void Score_free(struct LDKScore this_ptr);
34508 export function Score_free(this_ptr: bigint): void {
34509 if(!isWasmInitialized) {
34510 throw new Error("initializeWasm() must be awaited first!");
34512 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
34513 // debug statements here
34515 // void LockableScore_free(struct LDKLockableScore this_ptr);
34517 export function LockableScore_free(this_ptr: bigint): void {
34518 if(!isWasmInitialized) {
34519 throw new Error("initializeWasm() must be awaited first!");
34521 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
34522 // debug statements here
34524 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
34526 export function WriteableScore_free(this_ptr: bigint): void {
34527 if(!isWasmInitialized) {
34528 throw new Error("initializeWasm() must be awaited first!");
34530 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
34531 // debug statements here
34533 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
34535 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
34536 if(!isWasmInitialized) {
34537 throw new Error("initializeWasm() must be awaited first!");
34539 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
34540 // debug statements here
34542 // void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
34544 export function MultiThreadedScoreLock_free(this_obj: bigint): void {
34545 if(!isWasmInitialized) {
34546 throw new Error("initializeWasm() must be awaited first!");
34548 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
34549 // debug statements here
34551 // struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
34553 export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
34554 if(!isWasmInitialized) {
34555 throw new Error("initializeWasm() must be awaited first!");
34557 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
34558 return nativeResponseValue;
34560 // struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
34562 export function MultiThreadedScoreLock_write(obj: bigint): number {
34563 if(!isWasmInitialized) {
34564 throw new Error("initializeWasm() must be awaited first!");
34566 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
34567 return nativeResponseValue;
34569 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
34571 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
34572 if(!isWasmInitialized) {
34573 throw new Error("initializeWasm() must be awaited first!");
34575 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
34576 return nativeResponseValue;
34578 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
34580 export function MultiThreadedLockableScore_write(obj: bigint): number {
34581 if(!isWasmInitialized) {
34582 throw new Error("initializeWasm() must be awaited first!");
34584 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
34585 return nativeResponseValue;
34587 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
34589 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
34590 if(!isWasmInitialized) {
34591 throw new Error("initializeWasm() must be awaited first!");
34593 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
34594 return nativeResponseValue;
34596 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
34598 export function MultiThreadedLockableScore_new(score: bigint): bigint {
34599 if(!isWasmInitialized) {
34600 throw new Error("initializeWasm() must be awaited first!");
34602 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
34603 return nativeResponseValue;
34605 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
34607 export function ChannelUsage_free(this_obj: bigint): void {
34608 if(!isWasmInitialized) {
34609 throw new Error("initializeWasm() must be awaited first!");
34611 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
34612 // debug statements here
34614 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
34616 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
34617 if(!isWasmInitialized) {
34618 throw new Error("initializeWasm() must be awaited first!");
34620 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
34621 return nativeResponseValue;
34623 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
34625 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
34626 if(!isWasmInitialized) {
34627 throw new Error("initializeWasm() must be awaited first!");
34629 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
34630 // debug statements here
34632 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
34634 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
34635 if(!isWasmInitialized) {
34636 throw new Error("initializeWasm() must be awaited first!");
34638 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
34639 return nativeResponseValue;
34641 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
34643 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
34644 if(!isWasmInitialized) {
34645 throw new Error("initializeWasm() must be awaited first!");
34647 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
34648 // debug statements here
34650 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
34652 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
34653 if(!isWasmInitialized) {
34654 throw new Error("initializeWasm() must be awaited first!");
34656 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
34657 return nativeResponseValue;
34659 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
34661 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
34662 if(!isWasmInitialized) {
34663 throw new Error("initializeWasm() must be awaited first!");
34665 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
34666 // debug statements here
34668 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
34670 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
34671 if(!isWasmInitialized) {
34672 throw new Error("initializeWasm() must be awaited first!");
34674 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
34675 return nativeResponseValue;
34677 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
34679 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
34680 if(!isWasmInitialized) {
34681 throw new Error("initializeWasm() must be awaited first!");
34683 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
34684 return nativeResponseValue;
34686 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
34688 export function ChannelUsage_clone(orig: bigint): bigint {
34689 if(!isWasmInitialized) {
34690 throw new Error("initializeWasm() must be awaited first!");
34692 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
34693 return nativeResponseValue;
34695 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
34697 export function FixedPenaltyScorer_free(this_obj: bigint): void {
34698 if(!isWasmInitialized) {
34699 throw new Error("initializeWasm() must be awaited first!");
34701 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
34702 // debug statements here
34704 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
34706 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
34707 if(!isWasmInitialized) {
34708 throw new Error("initializeWasm() must be awaited first!");
34710 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
34711 return nativeResponseValue;
34713 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
34715 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
34716 if(!isWasmInitialized) {
34717 throw new Error("initializeWasm() must be awaited first!");
34719 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
34720 return nativeResponseValue;
34722 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
34724 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
34725 if(!isWasmInitialized) {
34726 throw new Error("initializeWasm() must be awaited first!");
34728 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
34729 return nativeResponseValue;
34731 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
34733 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
34734 if(!isWasmInitialized) {
34735 throw new Error("initializeWasm() must be awaited first!");
34737 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
34738 return nativeResponseValue;
34740 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
34742 export function FixedPenaltyScorer_write(obj: bigint): number {
34743 if(!isWasmInitialized) {
34744 throw new Error("initializeWasm() must be awaited first!");
34746 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
34747 return nativeResponseValue;
34749 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
34751 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
34752 if(!isWasmInitialized) {
34753 throw new Error("initializeWasm() must be awaited first!");
34755 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
34756 return nativeResponseValue;
34758 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
34760 export function ProbabilisticScorer_free(this_obj: bigint): void {
34761 if(!isWasmInitialized) {
34762 throw new Error("initializeWasm() must be awaited first!");
34764 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
34765 // debug statements here
34767 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
34769 export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
34770 if(!isWasmInitialized) {
34771 throw new Error("initializeWasm() must be awaited first!");
34773 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
34774 // debug statements here
34776 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34778 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
34779 if(!isWasmInitialized) {
34780 throw new Error("initializeWasm() must be awaited first!");
34782 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
34783 return nativeResponseValue;
34785 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34787 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
34788 if(!isWasmInitialized) {
34789 throw new Error("initializeWasm() must be awaited first!");
34791 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
34792 // debug statements here
34794 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34796 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
34797 if(!isWasmInitialized) {
34798 throw new Error("initializeWasm() must be awaited first!");
34800 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
34801 return nativeResponseValue;
34803 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34805 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
34806 if(!isWasmInitialized) {
34807 throw new Error("initializeWasm() must be awaited first!");
34809 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
34810 // debug statements here
34812 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34814 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
34815 if(!isWasmInitialized) {
34816 throw new Error("initializeWasm() must be awaited first!");
34818 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
34819 return nativeResponseValue;
34821 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34823 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
34824 if(!isWasmInitialized) {
34825 throw new Error("initializeWasm() must be awaited first!");
34827 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
34828 // debug statements here
34830 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34832 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
34833 if(!isWasmInitialized) {
34834 throw new Error("initializeWasm() must be awaited first!");
34836 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
34837 return nativeResponseValue;
34839 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34841 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
34842 if(!isWasmInitialized) {
34843 throw new Error("initializeWasm() must be awaited first!");
34845 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
34846 // debug statements here
34848 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34850 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
34851 if(!isWasmInitialized) {
34852 throw new Error("initializeWasm() must be awaited first!");
34854 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
34855 return nativeResponseValue;
34857 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34859 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
34860 if(!isWasmInitialized) {
34861 throw new Error("initializeWasm() must be awaited first!");
34863 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
34864 // debug statements here
34866 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34868 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
34869 if(!isWasmInitialized) {
34870 throw new Error("initializeWasm() must be awaited first!");
34872 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
34873 return nativeResponseValue;
34875 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34877 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
34878 if(!isWasmInitialized) {
34879 throw new Error("initializeWasm() must be awaited first!");
34881 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
34882 // debug statements here
34884 // uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34886 export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
34887 if(!isWasmInitialized) {
34888 throw new Error("initializeWasm() must be awaited first!");
34890 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
34891 return nativeResponseValue;
34893 // void ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34895 export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
34896 if(!isWasmInitialized) {
34897 throw new Error("initializeWasm() must be awaited first!");
34899 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
34900 // debug statements here
34902 // uint64_t ProbabilisticScoringParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34904 export function ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
34905 if(!isWasmInitialized) {
34906 throw new Error("initializeWasm() must be awaited first!");
34908 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr);
34909 return nativeResponseValue;
34911 // void ProbabilisticScoringParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34913 export function ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
34914 if(!isWasmInitialized) {
34915 throw new Error("initializeWasm() must be awaited first!");
34917 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr, val);
34918 // debug statements here
34920 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34922 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
34923 if(!isWasmInitialized) {
34924 throw new Error("initializeWasm() must be awaited first!");
34926 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
34927 return nativeResponseValue;
34929 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34931 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
34932 if(!isWasmInitialized) {
34933 throw new Error("initializeWasm() must be awaited first!");
34935 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
34936 // debug statements here
34938 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
34940 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
34941 if(!isWasmInitialized) {
34942 throw new Error("initializeWasm() must be awaited first!");
34944 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
34945 return nativeResponseValue;
34947 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
34949 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
34950 if(!isWasmInitialized) {
34951 throw new Error("initializeWasm() must be awaited first!");
34953 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
34954 // debug statements here
34956 // uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
34958 export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
34959 if(!isWasmInitialized) {
34960 throw new Error("initializeWasm() must be awaited first!");
34962 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
34963 return nativeResponseValue;
34965 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
34967 export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
34968 if(!isWasmInitialized) {
34969 throw new Error("initializeWasm() must be awaited first!");
34971 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
34972 return nativeResponseValue;
34974 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
34976 export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
34977 if(!isWasmInitialized) {
34978 throw new Error("initializeWasm() must be awaited first!");
34980 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
34981 return nativeResponseValue;
34983 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
34985 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
34986 if(!isWasmInitialized) {
34987 throw new Error("initializeWasm() must be awaited first!");
34989 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
34990 // debug statements here
34992 // 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);
34994 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
34995 if(!isWasmInitialized) {
34996 throw new Error("initializeWasm() must be awaited first!");
34998 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
34999 return nativeResponseValue;
35001 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
35003 export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
35004 if(!isWasmInitialized) {
35005 throw new Error("initializeWasm() must be awaited first!");
35007 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
35008 // debug statements here
35010 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
35012 export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
35013 if(!isWasmInitialized) {
35014 throw new Error("initializeWasm() must be awaited first!");
35016 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
35017 // debug statements here
35019 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
35021 export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
35022 if(!isWasmInitialized) {
35023 throw new Error("initializeWasm() must be awaited first!");
35025 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
35026 // debug statements here
35028 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
35030 export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
35031 if(!isWasmInitialized) {
35032 throw new Error("initializeWasm() must be awaited first!");
35034 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
35035 // debug statements here
35037 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
35039 export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
35040 if(!isWasmInitialized) {
35041 throw new Error("initializeWasm() must be awaited first!");
35043 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
35044 // debug statements here
35046 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
35048 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
35049 if(!isWasmInitialized) {
35050 throw new Error("initializeWasm() must be awaited first!");
35052 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
35053 // debug statements here
35055 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
35057 export function ProbabilisticScoringParameters_default(): bigint {
35058 if(!isWasmInitialized) {
35059 throw new Error("initializeWasm() must be awaited first!");
35061 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
35062 return nativeResponseValue;
35064 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
35066 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
35067 if(!isWasmInitialized) {
35068 throw new Error("initializeWasm() must be awaited first!");
35070 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
35071 return nativeResponseValue;
35073 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
35075 export function ProbabilisticScorer_write(obj: bigint): number {
35076 if(!isWasmInitialized) {
35077 throw new Error("initializeWasm() must be awaited first!");
35079 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
35080 return nativeResponseValue;
35082 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
35084 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
35085 if(!isWasmInitialized) {
35086 throw new Error("initializeWasm() must be awaited first!");
35088 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
35089 return nativeResponseValue;
35091 // void BlindedPath_free(struct LDKBlindedPath this_obj);
35093 export function BlindedPath_free(this_obj: bigint): void {
35094 if(!isWasmInitialized) {
35095 throw new Error("initializeWasm() must be awaited first!");
35097 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
35098 // debug statements here
35100 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
35102 export function BlindedPath_clone_ptr(arg: bigint): bigint {
35103 if(!isWasmInitialized) {
35104 throw new Error("initializeWasm() must be awaited first!");
35106 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
35107 return nativeResponseValue;
35109 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
35111 export function BlindedPath_clone(orig: bigint): bigint {
35112 if(!isWasmInitialized) {
35113 throw new Error("initializeWasm() must be awaited first!");
35115 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
35116 return nativeResponseValue;
35118 // void BlindedHop_free(struct LDKBlindedHop this_obj);
35120 export function BlindedHop_free(this_obj: bigint): void {
35121 if(!isWasmInitialized) {
35122 throw new Error("initializeWasm() must be awaited first!");
35124 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
35125 // debug statements here
35127 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
35129 export function BlindedHop_clone_ptr(arg: bigint): bigint {
35130 if(!isWasmInitialized) {
35131 throw new Error("initializeWasm() must be awaited first!");
35133 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
35134 return nativeResponseValue;
35136 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
35138 export function BlindedHop_clone(orig: bigint): bigint {
35139 if(!isWasmInitialized) {
35140 throw new Error("initializeWasm() must be awaited first!");
35142 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
35143 return nativeResponseValue;
35145 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKKeysInterface *NONNULL_PTR keys_manager);
35147 export function BlindedPath_new(node_pks: number, keys_manager: bigint): bigint {
35148 if(!isWasmInitialized) {
35149 throw new Error("initializeWasm() must be awaited first!");
35151 const nativeResponseValue = wasm.TS_BlindedPath_new(node_pks, keys_manager);
35152 return nativeResponseValue;
35154 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
35156 export function BlindedPath_write(obj: bigint): number {
35157 if(!isWasmInitialized) {
35158 throw new Error("initializeWasm() must be awaited first!");
35160 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
35161 return nativeResponseValue;
35163 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
35165 export function BlindedPath_read(ser: number): bigint {
35166 if(!isWasmInitialized) {
35167 throw new Error("initializeWasm() must be awaited first!");
35169 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
35170 return nativeResponseValue;
35172 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
35174 export function BlindedHop_write(obj: bigint): number {
35175 if(!isWasmInitialized) {
35176 throw new Error("initializeWasm() must be awaited first!");
35178 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
35179 return nativeResponseValue;
35181 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
35183 export function BlindedHop_read(ser: number): bigint {
35184 if(!isWasmInitialized) {
35185 throw new Error("initializeWasm() must be awaited first!");
35187 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
35188 return nativeResponseValue;
35190 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
35192 export function OnionMessenger_free(this_obj: bigint): void {
35193 if(!isWasmInitialized) {
35194 throw new Error("initializeWasm() must be awaited first!");
35196 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
35197 // debug statements here
35199 // void Destination_free(struct LDKDestination this_ptr);
35201 export function Destination_free(this_ptr: bigint): void {
35202 if(!isWasmInitialized) {
35203 throw new Error("initializeWasm() must be awaited first!");
35205 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
35206 // debug statements here
35208 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
35210 export function Destination_clone_ptr(arg: bigint): bigint {
35211 if(!isWasmInitialized) {
35212 throw new Error("initializeWasm() must be awaited first!");
35214 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
35215 return nativeResponseValue;
35217 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
35219 export function Destination_clone(orig: bigint): bigint {
35220 if(!isWasmInitialized) {
35221 throw new Error("initializeWasm() must be awaited first!");
35223 const nativeResponseValue = wasm.TS_Destination_clone(orig);
35224 return nativeResponseValue;
35226 // struct LDKDestination Destination_node(struct LDKPublicKey a);
35228 export function Destination_node(a: number): bigint {
35229 if(!isWasmInitialized) {
35230 throw new Error("initializeWasm() must be awaited first!");
35232 const nativeResponseValue = wasm.TS_Destination_node(a);
35233 return nativeResponseValue;
35235 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
35237 export function Destination_blinded_path(a: bigint): bigint {
35238 if(!isWasmInitialized) {
35239 throw new Error("initializeWasm() must be awaited first!");
35241 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
35242 return nativeResponseValue;
35244 // void SendError_free(struct LDKSendError this_ptr);
35246 export function SendError_free(this_ptr: bigint): void {
35247 if(!isWasmInitialized) {
35248 throw new Error("initializeWasm() must be awaited first!");
35250 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
35251 // debug statements here
35253 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
35255 export function SendError_clone_ptr(arg: bigint): bigint {
35256 if(!isWasmInitialized) {
35257 throw new Error("initializeWasm() must be awaited first!");
35259 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
35260 return nativeResponseValue;
35262 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
35264 export function SendError_clone(orig: bigint): bigint {
35265 if(!isWasmInitialized) {
35266 throw new Error("initializeWasm() must be awaited first!");
35268 const nativeResponseValue = wasm.TS_SendError_clone(orig);
35269 return nativeResponseValue;
35271 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
35273 export function SendError_secp256k1(a: Secp256k1Error): bigint {
35274 if(!isWasmInitialized) {
35275 throw new Error("initializeWasm() must be awaited first!");
35277 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
35278 return nativeResponseValue;
35280 // struct LDKSendError SendError_too_big_packet(void);
35282 export function SendError_too_big_packet(): bigint {
35283 if(!isWasmInitialized) {
35284 throw new Error("initializeWasm() must be awaited first!");
35286 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
35287 return nativeResponseValue;
35289 // struct LDKSendError SendError_too_few_blinded_hops(void);
35291 export function SendError_too_few_blinded_hops(): bigint {
35292 if(!isWasmInitialized) {
35293 throw new Error("initializeWasm() must be awaited first!");
35295 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
35296 return nativeResponseValue;
35298 // struct LDKSendError SendError_invalid_first_hop(void);
35300 export function SendError_invalid_first_hop(): bigint {
35301 if(!isWasmInitialized) {
35302 throw new Error("initializeWasm() must be awaited first!");
35304 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
35305 return nativeResponseValue;
35307 // struct LDKSendError SendError_invalid_message(void);
35309 export function SendError_invalid_message(): bigint {
35310 if(!isWasmInitialized) {
35311 throw new Error("initializeWasm() must be awaited first!");
35313 const nativeResponseValue = wasm.TS_SendError_invalid_message();
35314 return nativeResponseValue;
35316 // struct LDKSendError SendError_buffer_full(void);
35318 export function SendError_buffer_full(): bigint {
35319 if(!isWasmInitialized) {
35320 throw new Error("initializeWasm() must be awaited first!");
35322 const nativeResponseValue = wasm.TS_SendError_buffer_full();
35323 return nativeResponseValue;
35325 // struct LDKSendError SendError_get_node_id_failed(void);
35327 export function SendError_get_node_id_failed(): bigint {
35328 if(!isWasmInitialized) {
35329 throw new Error("initializeWasm() must be awaited first!");
35331 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
35332 return nativeResponseValue;
35334 // struct LDKSendError SendError_blinded_path_advance_failed(void);
35336 export function SendError_blinded_path_advance_failed(): bigint {
35337 if(!isWasmInitialized) {
35338 throw new Error("initializeWasm() must be awaited first!");
35340 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
35341 return nativeResponseValue;
35343 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
35345 export function SendError_eq(a: bigint, b: bigint): boolean {
35346 if(!isWasmInitialized) {
35347 throw new Error("initializeWasm() must be awaited first!");
35349 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
35350 return nativeResponseValue;
35352 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
35354 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
35355 if(!isWasmInitialized) {
35356 throw new Error("initializeWasm() must be awaited first!");
35358 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
35359 // debug statements here
35361 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKKeysInterface keys_manager, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
35363 export function OnionMessenger_new(keys_manager: bigint, logger: bigint, custom_handler: bigint): bigint {
35364 if(!isWasmInitialized) {
35365 throw new Error("initializeWasm() must be awaited first!");
35367 const nativeResponseValue = wasm.TS_OnionMessenger_new(keys_manager, logger, custom_handler);
35368 return nativeResponseValue;
35370 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
35372 export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, message: bigint, reply_path: bigint): bigint {
35373 if(!isWasmInitialized) {
35374 throw new Error("initializeWasm() must be awaited first!");
35376 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, message, reply_path);
35377 return nativeResponseValue;
35379 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
35381 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
35382 if(!isWasmInitialized) {
35383 throw new Error("initializeWasm() must be awaited first!");
35385 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
35386 return nativeResponseValue;
35388 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
35390 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
35391 if(!isWasmInitialized) {
35392 throw new Error("initializeWasm() must be awaited first!");
35394 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
35395 return nativeResponseValue;
35397 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
35399 export function OnionMessageContents_free(this_ptr: bigint): void {
35400 if(!isWasmInitialized) {
35401 throw new Error("initializeWasm() must be awaited first!");
35403 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
35404 // debug statements here
35406 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
35408 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
35409 if(!isWasmInitialized) {
35410 throw new Error("initializeWasm() must be awaited first!");
35412 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
35413 return nativeResponseValue;
35415 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
35417 export function OnionMessageContents_clone(orig: bigint): bigint {
35418 if(!isWasmInitialized) {
35419 throw new Error("initializeWasm() must be awaited first!");
35421 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
35422 return nativeResponseValue;
35424 // struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
35426 export function OnionMessageContents_custom(a: bigint): bigint {
35427 if(!isWasmInitialized) {
35428 throw new Error("initializeWasm() must be awaited first!");
35430 const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
35431 return nativeResponseValue;
35433 // uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
35435 export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
35436 if(!isWasmInitialized) {
35437 throw new Error("initializeWasm() must be awaited first!");
35439 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
35440 return nativeResponseValue;
35442 // struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
35444 export function CustomOnionMessageContents_clone(orig: bigint): bigint {
35445 if(!isWasmInitialized) {
35446 throw new Error("initializeWasm() must be awaited first!");
35448 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
35449 return nativeResponseValue;
35451 // void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
35453 export function CustomOnionMessageContents_free(this_ptr: bigint): void {
35454 if(!isWasmInitialized) {
35455 throw new Error("initializeWasm() must be awaited first!");
35457 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
35458 // debug statements here
35460 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
35462 export function RapidGossipSync_free(this_obj: bigint): void {
35463 if(!isWasmInitialized) {
35464 throw new Error("initializeWasm() must be awaited first!");
35466 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
35467 // debug statements here
35469 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
35471 export function RapidGossipSync_new(network_graph: bigint): bigint {
35472 if(!isWasmInitialized) {
35473 throw new Error("initializeWasm() must be awaited first!");
35475 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph);
35476 return nativeResponseValue;
35478 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data);
35480 export function RapidGossipSync_update_network_graph(this_arg: bigint, update_data: number): bigint {
35481 if(!isWasmInitialized) {
35482 throw new Error("initializeWasm() must be awaited first!");
35484 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph(this_arg, update_data);
35485 return nativeResponseValue;
35487 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
35489 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
35490 if(!isWasmInitialized) {
35491 throw new Error("initializeWasm() must be awaited first!");
35493 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
35494 return nativeResponseValue;
35496 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
35498 export function GraphSyncError_free(this_ptr: bigint): void {
35499 if(!isWasmInitialized) {
35500 throw new Error("initializeWasm() must be awaited first!");
35502 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
35503 // debug statements here
35505 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
35507 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
35508 if(!isWasmInitialized) {
35509 throw new Error("initializeWasm() must be awaited first!");
35511 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
35512 return nativeResponseValue;
35514 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
35516 export function GraphSyncError_clone(orig: bigint): bigint {
35517 if(!isWasmInitialized) {
35518 throw new Error("initializeWasm() must be awaited first!");
35520 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
35521 return nativeResponseValue;
35523 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
35525 export function GraphSyncError_decode_error(a: bigint): bigint {
35526 if(!isWasmInitialized) {
35527 throw new Error("initializeWasm() must be awaited first!");
35529 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
35530 return nativeResponseValue;
35532 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
35534 export function GraphSyncError_lightning_error(a: bigint): bigint {
35535 if(!isWasmInitialized) {
35536 throw new Error("initializeWasm() must be awaited first!");
35538 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
35539 return nativeResponseValue;
35541 // void ParseError_free(struct LDKParseError this_ptr);
35543 export function ParseError_free(this_ptr: bigint): void {
35544 if(!isWasmInitialized) {
35545 throw new Error("initializeWasm() must be awaited first!");
35547 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
35548 // debug statements here
35550 // uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
35552 export function ParseError_clone_ptr(arg: bigint): bigint {
35553 if(!isWasmInitialized) {
35554 throw new Error("initializeWasm() must be awaited first!");
35556 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
35557 return nativeResponseValue;
35559 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
35561 export function ParseError_clone(orig: bigint): bigint {
35562 if(!isWasmInitialized) {
35563 throw new Error("initializeWasm() must be awaited first!");
35565 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
35566 return nativeResponseValue;
35568 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
35570 export function ParseError_bech32_error(a: bigint): bigint {
35571 if(!isWasmInitialized) {
35572 throw new Error("initializeWasm() must be awaited first!");
35574 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
35575 return nativeResponseValue;
35577 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
35579 export function ParseError_parse_amount_error(a: number): bigint {
35580 if(!isWasmInitialized) {
35581 throw new Error("initializeWasm() must be awaited first!");
35583 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
35584 return nativeResponseValue;
35586 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
35588 export function ParseError_malformed_signature(a: Secp256k1Error): bigint {
35589 if(!isWasmInitialized) {
35590 throw new Error("initializeWasm() must be awaited first!");
35592 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
35593 return nativeResponseValue;
35595 // struct LDKParseError ParseError_bad_prefix(void);
35597 export function ParseError_bad_prefix(): bigint {
35598 if(!isWasmInitialized) {
35599 throw new Error("initializeWasm() must be awaited first!");
35601 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
35602 return nativeResponseValue;
35604 // struct LDKParseError ParseError_unknown_currency(void);
35606 export function ParseError_unknown_currency(): bigint {
35607 if(!isWasmInitialized) {
35608 throw new Error("initializeWasm() must be awaited first!");
35610 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
35611 return nativeResponseValue;
35613 // struct LDKParseError ParseError_unknown_si_prefix(void);
35615 export function ParseError_unknown_si_prefix(): bigint {
35616 if(!isWasmInitialized) {
35617 throw new Error("initializeWasm() must be awaited first!");
35619 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
35620 return nativeResponseValue;
35622 // struct LDKParseError ParseError_malformed_hrp(void);
35624 export function ParseError_malformed_hrp(): bigint {
35625 if(!isWasmInitialized) {
35626 throw new Error("initializeWasm() must be awaited first!");
35628 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
35629 return nativeResponseValue;
35631 // struct LDKParseError ParseError_too_short_data_part(void);
35633 export function ParseError_too_short_data_part(): bigint {
35634 if(!isWasmInitialized) {
35635 throw new Error("initializeWasm() must be awaited first!");
35637 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
35638 return nativeResponseValue;
35640 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
35642 export function ParseError_unexpected_end_of_tagged_fields(): bigint {
35643 if(!isWasmInitialized) {
35644 throw new Error("initializeWasm() must be awaited first!");
35646 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
35647 return nativeResponseValue;
35649 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
35651 export function ParseError_description_decode_error(a: number): bigint {
35652 if(!isWasmInitialized) {
35653 throw new Error("initializeWasm() must be awaited first!");
35655 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
35656 return nativeResponseValue;
35658 // struct LDKParseError ParseError_padding_error(void);
35660 export function ParseError_padding_error(): bigint {
35661 if(!isWasmInitialized) {
35662 throw new Error("initializeWasm() must be awaited first!");
35664 const nativeResponseValue = wasm.TS_ParseError_padding_error();
35665 return nativeResponseValue;
35667 // struct LDKParseError ParseError_integer_overflow_error(void);
35669 export function ParseError_integer_overflow_error(): bigint {
35670 if(!isWasmInitialized) {
35671 throw new Error("initializeWasm() must be awaited first!");
35673 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
35674 return nativeResponseValue;
35676 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
35678 export function ParseError_invalid_seg_wit_program_length(): bigint {
35679 if(!isWasmInitialized) {
35680 throw new Error("initializeWasm() must be awaited first!");
35682 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
35683 return nativeResponseValue;
35685 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
35687 export function ParseError_invalid_pub_key_hash_length(): bigint {
35688 if(!isWasmInitialized) {
35689 throw new Error("initializeWasm() must be awaited first!");
35691 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
35692 return nativeResponseValue;
35694 // struct LDKParseError ParseError_invalid_script_hash_length(void);
35696 export function ParseError_invalid_script_hash_length(): bigint {
35697 if(!isWasmInitialized) {
35698 throw new Error("initializeWasm() must be awaited first!");
35700 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
35701 return nativeResponseValue;
35703 // struct LDKParseError ParseError_invalid_recovery_id(void);
35705 export function ParseError_invalid_recovery_id(): bigint {
35706 if(!isWasmInitialized) {
35707 throw new Error("initializeWasm() must be awaited first!");
35709 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
35710 return nativeResponseValue;
35712 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
35714 export function ParseError_invalid_slice_length(a: number): bigint {
35715 if(!isWasmInitialized) {
35716 throw new Error("initializeWasm() must be awaited first!");
35718 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
35719 return nativeResponseValue;
35721 // struct LDKParseError ParseError_skip(void);
35723 export function ParseError_skip(): bigint {
35724 if(!isWasmInitialized) {
35725 throw new Error("initializeWasm() must be awaited first!");
35727 const nativeResponseValue = wasm.TS_ParseError_skip();
35728 return nativeResponseValue;
35730 // bool ParseError_eq(const struct LDKParseError *NONNULL_PTR a, const struct LDKParseError *NONNULL_PTR b);
35732 export function ParseError_eq(a: bigint, b: bigint): boolean {
35733 if(!isWasmInitialized) {
35734 throw new Error("initializeWasm() must be awaited first!");
35736 const nativeResponseValue = wasm.TS_ParseError_eq(a, b);
35737 return nativeResponseValue;
35739 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
35741 export function ParseOrSemanticError_free(this_ptr: bigint): void {
35742 if(!isWasmInitialized) {
35743 throw new Error("initializeWasm() must be awaited first!");
35745 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
35746 // debug statements here
35748 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
35750 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
35751 if(!isWasmInitialized) {
35752 throw new Error("initializeWasm() must be awaited first!");
35754 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
35755 return nativeResponseValue;
35757 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
35759 export function ParseOrSemanticError_clone(orig: bigint): bigint {
35760 if(!isWasmInitialized) {
35761 throw new Error("initializeWasm() must be awaited first!");
35763 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
35764 return nativeResponseValue;
35766 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
35768 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
35769 if(!isWasmInitialized) {
35770 throw new Error("initializeWasm() must be awaited first!");
35772 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
35773 return nativeResponseValue;
35775 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
35777 export function ParseOrSemanticError_semantic_error(a: SemanticError): bigint {
35778 if(!isWasmInitialized) {
35779 throw new Error("initializeWasm() must be awaited first!");
35781 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
35782 return nativeResponseValue;
35784 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
35786 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
35787 if(!isWasmInitialized) {
35788 throw new Error("initializeWasm() must be awaited first!");
35790 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
35791 return nativeResponseValue;
35793 // void Invoice_free(struct LDKInvoice this_obj);
35795 export function Invoice_free(this_obj: bigint): void {
35796 if(!isWasmInitialized) {
35797 throw new Error("initializeWasm() must be awaited first!");
35799 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
35800 // debug statements here
35802 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
35804 export function Invoice_eq(a: bigint, b: bigint): boolean {
35805 if(!isWasmInitialized) {
35806 throw new Error("initializeWasm() must be awaited first!");
35808 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
35809 return nativeResponseValue;
35811 // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
35813 export function Invoice_clone_ptr(arg: bigint): bigint {
35814 if(!isWasmInitialized) {
35815 throw new Error("initializeWasm() must be awaited first!");
35817 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
35818 return nativeResponseValue;
35820 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
35822 export function Invoice_clone(orig: bigint): bigint {
35823 if(!isWasmInitialized) {
35824 throw new Error("initializeWasm() must be awaited first!");
35826 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
35827 return nativeResponseValue;
35829 // uint64_t Invoice_hash(const struct LDKInvoice *NONNULL_PTR o);
35831 export function Invoice_hash(o: bigint): bigint {
35832 if(!isWasmInitialized) {
35833 throw new Error("initializeWasm() must be awaited first!");
35835 const nativeResponseValue = wasm.TS_Invoice_hash(o);
35836 return nativeResponseValue;
35838 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
35840 export function SignedRawInvoice_free(this_obj: bigint): void {
35841 if(!isWasmInitialized) {
35842 throw new Error("initializeWasm() must be awaited first!");
35844 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
35845 // debug statements here
35847 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
35849 export function SignedRawInvoice_eq(a: bigint, b: bigint): boolean {
35850 if(!isWasmInitialized) {
35851 throw new Error("initializeWasm() must be awaited first!");
35853 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
35854 return nativeResponseValue;
35856 // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
35858 export function SignedRawInvoice_clone_ptr(arg: bigint): bigint {
35859 if(!isWasmInitialized) {
35860 throw new Error("initializeWasm() must be awaited first!");
35862 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
35863 return nativeResponseValue;
35865 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
35867 export function SignedRawInvoice_clone(orig: bigint): bigint {
35868 if(!isWasmInitialized) {
35869 throw new Error("initializeWasm() must be awaited first!");
35871 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
35872 return nativeResponseValue;
35874 // uint64_t SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR o);
35876 export function SignedRawInvoice_hash(o: bigint): bigint {
35877 if(!isWasmInitialized) {
35878 throw new Error("initializeWasm() must be awaited first!");
35880 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(o);
35881 return nativeResponseValue;
35883 // void RawInvoice_free(struct LDKRawInvoice this_obj);
35885 export function RawInvoice_free(this_obj: bigint): void {
35886 if(!isWasmInitialized) {
35887 throw new Error("initializeWasm() must be awaited first!");
35889 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
35890 // debug statements here
35892 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
35894 export function RawInvoice_get_data(this_ptr: bigint): bigint {
35895 if(!isWasmInitialized) {
35896 throw new Error("initializeWasm() must be awaited first!");
35898 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
35899 return nativeResponseValue;
35901 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
35903 export function RawInvoice_set_data(this_ptr: bigint, val: bigint): void {
35904 if(!isWasmInitialized) {
35905 throw new Error("initializeWasm() must be awaited first!");
35907 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
35908 // debug statements here
35910 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
35912 export function RawInvoice_eq(a: bigint, b: bigint): boolean {
35913 if(!isWasmInitialized) {
35914 throw new Error("initializeWasm() must be awaited first!");
35916 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
35917 return nativeResponseValue;
35919 // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
35921 export function RawInvoice_clone_ptr(arg: bigint): bigint {
35922 if(!isWasmInitialized) {
35923 throw new Error("initializeWasm() must be awaited first!");
35925 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
35926 return nativeResponseValue;
35928 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
35930 export function RawInvoice_clone(orig: bigint): bigint {
35931 if(!isWasmInitialized) {
35932 throw new Error("initializeWasm() must be awaited first!");
35934 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
35935 return nativeResponseValue;
35937 // uint64_t RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR o);
35939 export function RawInvoice_hash(o: bigint): bigint {
35940 if(!isWasmInitialized) {
35941 throw new Error("initializeWasm() must be awaited first!");
35943 const nativeResponseValue = wasm.TS_RawInvoice_hash(o);
35944 return nativeResponseValue;
35946 // void RawDataPart_free(struct LDKRawDataPart this_obj);
35948 export function RawDataPart_free(this_obj: bigint): void {
35949 if(!isWasmInitialized) {
35950 throw new Error("initializeWasm() must be awaited first!");
35952 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
35953 // debug statements here
35955 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
35957 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
35958 if(!isWasmInitialized) {
35959 throw new Error("initializeWasm() must be awaited first!");
35961 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
35962 return nativeResponseValue;
35964 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
35966 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
35967 if(!isWasmInitialized) {
35968 throw new Error("initializeWasm() must be awaited first!");
35970 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
35971 // debug statements here
35973 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
35975 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
35976 if(!isWasmInitialized) {
35977 throw new Error("initializeWasm() must be awaited first!");
35979 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
35980 return nativeResponseValue;
35982 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
35984 export function RawDataPart_clone_ptr(arg: bigint): bigint {
35985 if(!isWasmInitialized) {
35986 throw new Error("initializeWasm() must be awaited first!");
35988 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
35989 return nativeResponseValue;
35991 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
35993 export function RawDataPart_clone(orig: bigint): bigint {
35994 if(!isWasmInitialized) {
35995 throw new Error("initializeWasm() must be awaited first!");
35997 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
35998 return nativeResponseValue;
36000 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
36002 export function RawDataPart_hash(o: bigint): bigint {
36003 if(!isWasmInitialized) {
36004 throw new Error("initializeWasm() must be awaited first!");
36006 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
36007 return nativeResponseValue;
36009 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
36011 export function PositiveTimestamp_free(this_obj: bigint): void {
36012 if(!isWasmInitialized) {
36013 throw new Error("initializeWasm() must be awaited first!");
36015 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
36016 // debug statements here
36018 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
36020 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
36021 if(!isWasmInitialized) {
36022 throw new Error("initializeWasm() must be awaited first!");
36024 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
36025 return nativeResponseValue;
36027 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
36029 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
36030 if(!isWasmInitialized) {
36031 throw new Error("initializeWasm() must be awaited first!");
36033 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
36034 return nativeResponseValue;
36036 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
36038 export function PositiveTimestamp_clone(orig: bigint): bigint {
36039 if(!isWasmInitialized) {
36040 throw new Error("initializeWasm() must be awaited first!");
36042 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
36043 return nativeResponseValue;
36045 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
36047 export function PositiveTimestamp_hash(o: bigint): bigint {
36048 if(!isWasmInitialized) {
36049 throw new Error("initializeWasm() must be awaited first!");
36051 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
36052 return nativeResponseValue;
36054 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
36056 export function SiPrefix_clone(orig: bigint): SiPrefix {
36057 if(!isWasmInitialized) {
36058 throw new Error("initializeWasm() must be awaited first!");
36060 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
36061 return nativeResponseValue;
36063 // enum LDKSiPrefix SiPrefix_milli(void);
36065 export function SiPrefix_milli(): SiPrefix {
36066 if(!isWasmInitialized) {
36067 throw new Error("initializeWasm() must be awaited first!");
36069 const nativeResponseValue = wasm.TS_SiPrefix_milli();
36070 return nativeResponseValue;
36072 // enum LDKSiPrefix SiPrefix_micro(void);
36074 export function SiPrefix_micro(): SiPrefix {
36075 if(!isWasmInitialized) {
36076 throw new Error("initializeWasm() must be awaited first!");
36078 const nativeResponseValue = wasm.TS_SiPrefix_micro();
36079 return nativeResponseValue;
36081 // enum LDKSiPrefix SiPrefix_nano(void);
36083 export function SiPrefix_nano(): SiPrefix {
36084 if(!isWasmInitialized) {
36085 throw new Error("initializeWasm() must be awaited first!");
36087 const nativeResponseValue = wasm.TS_SiPrefix_nano();
36088 return nativeResponseValue;
36090 // enum LDKSiPrefix SiPrefix_pico(void);
36092 export function SiPrefix_pico(): SiPrefix {
36093 if(!isWasmInitialized) {
36094 throw new Error("initializeWasm() must be awaited first!");
36096 const nativeResponseValue = wasm.TS_SiPrefix_pico();
36097 return nativeResponseValue;
36099 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
36101 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
36102 if(!isWasmInitialized) {
36103 throw new Error("initializeWasm() must be awaited first!");
36105 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
36106 return nativeResponseValue;
36108 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
36110 export function SiPrefix_hash(o: bigint): bigint {
36111 if(!isWasmInitialized) {
36112 throw new Error("initializeWasm() must be awaited first!");
36114 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
36115 return nativeResponseValue;
36117 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
36119 export function SiPrefix_multiplier(this_arg: bigint): bigint {
36120 if(!isWasmInitialized) {
36121 throw new Error("initializeWasm() must be awaited first!");
36123 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
36124 return nativeResponseValue;
36126 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
36128 export function Currency_clone(orig: bigint): Currency {
36129 if(!isWasmInitialized) {
36130 throw new Error("initializeWasm() must be awaited first!");
36132 const nativeResponseValue = wasm.TS_Currency_clone(orig);
36133 return nativeResponseValue;
36135 // enum LDKCurrency Currency_bitcoin(void);
36137 export function Currency_bitcoin(): Currency {
36138 if(!isWasmInitialized) {
36139 throw new Error("initializeWasm() must be awaited first!");
36141 const nativeResponseValue = wasm.TS_Currency_bitcoin();
36142 return nativeResponseValue;
36144 // enum LDKCurrency Currency_bitcoin_testnet(void);
36146 export function Currency_bitcoin_testnet(): Currency {
36147 if(!isWasmInitialized) {
36148 throw new Error("initializeWasm() must be awaited first!");
36150 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
36151 return nativeResponseValue;
36153 // enum LDKCurrency Currency_regtest(void);
36155 export function Currency_regtest(): Currency {
36156 if(!isWasmInitialized) {
36157 throw new Error("initializeWasm() must be awaited first!");
36159 const nativeResponseValue = wasm.TS_Currency_regtest();
36160 return nativeResponseValue;
36162 // enum LDKCurrency Currency_simnet(void);
36164 export function Currency_simnet(): Currency {
36165 if(!isWasmInitialized) {
36166 throw new Error("initializeWasm() must be awaited first!");
36168 const nativeResponseValue = wasm.TS_Currency_simnet();
36169 return nativeResponseValue;
36171 // enum LDKCurrency Currency_signet(void);
36173 export function Currency_signet(): Currency {
36174 if(!isWasmInitialized) {
36175 throw new Error("initializeWasm() must be awaited first!");
36177 const nativeResponseValue = wasm.TS_Currency_signet();
36178 return nativeResponseValue;
36180 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
36182 export function Currency_hash(o: bigint): bigint {
36183 if(!isWasmInitialized) {
36184 throw new Error("initializeWasm() must be awaited first!");
36186 const nativeResponseValue = wasm.TS_Currency_hash(o);
36187 return nativeResponseValue;
36189 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
36191 export function Currency_eq(a: bigint, b: bigint): boolean {
36192 if(!isWasmInitialized) {
36193 throw new Error("initializeWasm() must be awaited first!");
36195 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
36196 return nativeResponseValue;
36198 // void Sha256_free(struct LDKSha256 this_obj);
36200 export function Sha256_free(this_obj: bigint): void {
36201 if(!isWasmInitialized) {
36202 throw new Error("initializeWasm() must be awaited first!");
36204 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
36205 // debug statements here
36207 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
36209 export function Sha256_clone_ptr(arg: bigint): bigint {
36210 if(!isWasmInitialized) {
36211 throw new Error("initializeWasm() must be awaited first!");
36213 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
36214 return nativeResponseValue;
36216 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
36218 export function Sha256_clone(orig: bigint): bigint {
36219 if(!isWasmInitialized) {
36220 throw new Error("initializeWasm() must be awaited first!");
36222 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
36223 return nativeResponseValue;
36225 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
36227 export function Sha256_hash(o: bigint): bigint {
36228 if(!isWasmInitialized) {
36229 throw new Error("initializeWasm() must be awaited first!");
36231 const nativeResponseValue = wasm.TS_Sha256_hash(o);
36232 return nativeResponseValue;
36234 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
36236 export function Sha256_eq(a: bigint, b: bigint): boolean {
36237 if(!isWasmInitialized) {
36238 throw new Error("initializeWasm() must be awaited first!");
36240 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
36241 return nativeResponseValue;
36243 // void Description_free(struct LDKDescription this_obj);
36245 export function Description_free(this_obj: bigint): void {
36246 if(!isWasmInitialized) {
36247 throw new Error("initializeWasm() must be awaited first!");
36249 const nativeResponseValue = wasm.TS_Description_free(this_obj);
36250 // debug statements here
36252 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
36254 export function Description_clone_ptr(arg: bigint): bigint {
36255 if(!isWasmInitialized) {
36256 throw new Error("initializeWasm() must be awaited first!");
36258 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
36259 return nativeResponseValue;
36261 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
36263 export function Description_clone(orig: bigint): bigint {
36264 if(!isWasmInitialized) {
36265 throw new Error("initializeWasm() must be awaited first!");
36267 const nativeResponseValue = wasm.TS_Description_clone(orig);
36268 return nativeResponseValue;
36270 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
36272 export function Description_hash(o: bigint): bigint {
36273 if(!isWasmInitialized) {
36274 throw new Error("initializeWasm() must be awaited first!");
36276 const nativeResponseValue = wasm.TS_Description_hash(o);
36277 return nativeResponseValue;
36279 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
36281 export function Description_eq(a: bigint, b: bigint): boolean {
36282 if(!isWasmInitialized) {
36283 throw new Error("initializeWasm() must be awaited first!");
36285 const nativeResponseValue = wasm.TS_Description_eq(a, b);
36286 return nativeResponseValue;
36288 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
36290 export function PayeePubKey_free(this_obj: bigint): void {
36291 if(!isWasmInitialized) {
36292 throw new Error("initializeWasm() must be awaited first!");
36294 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
36295 // debug statements here
36297 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
36299 export function PayeePubKey_get_a(this_ptr: bigint): number {
36300 if(!isWasmInitialized) {
36301 throw new Error("initializeWasm() must be awaited first!");
36303 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
36304 return nativeResponseValue;
36306 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36308 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
36309 if(!isWasmInitialized) {
36310 throw new Error("initializeWasm() must be awaited first!");
36312 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
36313 // debug statements here
36315 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
36317 export function PayeePubKey_new(a_arg: number): bigint {
36318 if(!isWasmInitialized) {
36319 throw new Error("initializeWasm() must be awaited first!");
36321 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
36322 return nativeResponseValue;
36324 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
36326 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
36327 if(!isWasmInitialized) {
36328 throw new Error("initializeWasm() must be awaited first!");
36330 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
36331 return nativeResponseValue;
36333 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
36335 export function PayeePubKey_clone(orig: bigint): bigint {
36336 if(!isWasmInitialized) {
36337 throw new Error("initializeWasm() must be awaited first!");
36339 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
36340 return nativeResponseValue;
36342 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
36344 export function PayeePubKey_hash(o: bigint): bigint {
36345 if(!isWasmInitialized) {
36346 throw new Error("initializeWasm() must be awaited first!");
36348 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
36349 return nativeResponseValue;
36351 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
36353 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
36354 if(!isWasmInitialized) {
36355 throw new Error("initializeWasm() must be awaited first!");
36357 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
36358 return nativeResponseValue;
36360 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
36362 export function ExpiryTime_free(this_obj: bigint): void {
36363 if(!isWasmInitialized) {
36364 throw new Error("initializeWasm() must be awaited first!");
36366 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
36367 // debug statements here
36369 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
36371 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
36372 if(!isWasmInitialized) {
36373 throw new Error("initializeWasm() must be awaited first!");
36375 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
36376 return nativeResponseValue;
36378 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
36380 export function ExpiryTime_clone(orig: bigint): bigint {
36381 if(!isWasmInitialized) {
36382 throw new Error("initializeWasm() must be awaited first!");
36384 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
36385 return nativeResponseValue;
36387 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
36389 export function ExpiryTime_hash(o: bigint): bigint {
36390 if(!isWasmInitialized) {
36391 throw new Error("initializeWasm() must be awaited first!");
36393 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
36394 return nativeResponseValue;
36396 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
36398 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
36399 if(!isWasmInitialized) {
36400 throw new Error("initializeWasm() must be awaited first!");
36402 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
36403 return nativeResponseValue;
36405 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
36407 export function MinFinalCltvExpiry_free(this_obj: bigint): void {
36408 if(!isWasmInitialized) {
36409 throw new Error("initializeWasm() must be awaited first!");
36411 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
36412 // debug statements here
36414 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
36416 export function MinFinalCltvExpiry_get_a(this_ptr: bigint): bigint {
36417 if(!isWasmInitialized) {
36418 throw new Error("initializeWasm() must be awaited first!");
36420 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
36421 return nativeResponseValue;
36423 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
36425 export function MinFinalCltvExpiry_set_a(this_ptr: bigint, val: bigint): void {
36426 if(!isWasmInitialized) {
36427 throw new Error("initializeWasm() must be awaited first!");
36429 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
36430 // debug statements here
36432 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
36434 export function MinFinalCltvExpiry_new(a_arg: bigint): bigint {
36435 if(!isWasmInitialized) {
36436 throw new Error("initializeWasm() must be awaited first!");
36438 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
36439 return nativeResponseValue;
36441 // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
36443 export function MinFinalCltvExpiry_clone_ptr(arg: bigint): bigint {
36444 if(!isWasmInitialized) {
36445 throw new Error("initializeWasm() must be awaited first!");
36447 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
36448 return nativeResponseValue;
36450 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
36452 export function MinFinalCltvExpiry_clone(orig: bigint): bigint {
36453 if(!isWasmInitialized) {
36454 throw new Error("initializeWasm() must be awaited first!");
36456 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
36457 return nativeResponseValue;
36459 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
36461 export function MinFinalCltvExpiry_hash(o: bigint): bigint {
36462 if(!isWasmInitialized) {
36463 throw new Error("initializeWasm() must be awaited first!");
36465 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
36466 return nativeResponseValue;
36468 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
36470 export function MinFinalCltvExpiry_eq(a: bigint, b: bigint): boolean {
36471 if(!isWasmInitialized) {
36472 throw new Error("initializeWasm() must be awaited first!");
36474 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
36475 return nativeResponseValue;
36477 // void Fallback_free(struct LDKFallback this_ptr);
36479 export function Fallback_free(this_ptr: bigint): void {
36480 if(!isWasmInitialized) {
36481 throw new Error("initializeWasm() must be awaited first!");
36483 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
36484 // debug statements here
36486 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
36488 export function Fallback_clone_ptr(arg: bigint): bigint {
36489 if(!isWasmInitialized) {
36490 throw new Error("initializeWasm() must be awaited first!");
36492 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
36493 return nativeResponseValue;
36495 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
36497 export function Fallback_clone(orig: bigint): bigint {
36498 if(!isWasmInitialized) {
36499 throw new Error("initializeWasm() must be awaited first!");
36501 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
36502 return nativeResponseValue;
36504 // struct LDKFallback Fallback_seg_wit_program(struct LDKU5 version, struct LDKCVec_u8Z program);
36506 export function Fallback_seg_wit_program(version: number, program: number): bigint {
36507 if(!isWasmInitialized) {
36508 throw new Error("initializeWasm() must be awaited first!");
36510 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
36511 return nativeResponseValue;
36513 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
36515 export function Fallback_pub_key_hash(a: number): bigint {
36516 if(!isWasmInitialized) {
36517 throw new Error("initializeWasm() must be awaited first!");
36519 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
36520 return nativeResponseValue;
36522 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
36524 export function Fallback_script_hash(a: number): bigint {
36525 if(!isWasmInitialized) {
36526 throw new Error("initializeWasm() must be awaited first!");
36528 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
36529 return nativeResponseValue;
36531 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
36533 export function Fallback_hash(o: bigint): bigint {
36534 if(!isWasmInitialized) {
36535 throw new Error("initializeWasm() must be awaited first!");
36537 const nativeResponseValue = wasm.TS_Fallback_hash(o);
36538 return nativeResponseValue;
36540 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
36542 export function Fallback_eq(a: bigint, b: bigint): boolean {
36543 if(!isWasmInitialized) {
36544 throw new Error("initializeWasm() must be awaited first!");
36546 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
36547 return nativeResponseValue;
36549 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
36551 export function InvoiceSignature_free(this_obj: bigint): void {
36552 if(!isWasmInitialized) {
36553 throw new Error("initializeWasm() must be awaited first!");
36555 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
36556 // debug statements here
36558 // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
36560 export function InvoiceSignature_clone_ptr(arg: bigint): bigint {
36561 if(!isWasmInitialized) {
36562 throw new Error("initializeWasm() must be awaited first!");
36564 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
36565 return nativeResponseValue;
36567 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
36569 export function InvoiceSignature_clone(orig: bigint): bigint {
36570 if(!isWasmInitialized) {
36571 throw new Error("initializeWasm() must be awaited first!");
36573 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
36574 return nativeResponseValue;
36576 // uint64_t InvoiceSignature_hash(const struct LDKInvoiceSignature *NONNULL_PTR o);
36578 export function InvoiceSignature_hash(o: bigint): bigint {
36579 if(!isWasmInitialized) {
36580 throw new Error("initializeWasm() must be awaited first!");
36582 const nativeResponseValue = wasm.TS_InvoiceSignature_hash(o);
36583 return nativeResponseValue;
36585 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
36587 export function InvoiceSignature_eq(a: bigint, b: bigint): boolean {
36588 if(!isWasmInitialized) {
36589 throw new Error("initializeWasm() must be awaited first!");
36591 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
36592 return nativeResponseValue;
36594 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
36596 export function PrivateRoute_free(this_obj: bigint): void {
36597 if(!isWasmInitialized) {
36598 throw new Error("initializeWasm() must be awaited first!");
36600 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
36601 // debug statements here
36603 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
36605 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
36606 if(!isWasmInitialized) {
36607 throw new Error("initializeWasm() must be awaited first!");
36609 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
36610 return nativeResponseValue;
36612 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
36614 export function PrivateRoute_clone(orig: bigint): bigint {
36615 if(!isWasmInitialized) {
36616 throw new Error("initializeWasm() must be awaited first!");
36618 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
36619 return nativeResponseValue;
36621 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
36623 export function PrivateRoute_hash(o: bigint): bigint {
36624 if(!isWasmInitialized) {
36625 throw new Error("initializeWasm() must be awaited first!");
36627 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
36628 return nativeResponseValue;
36630 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
36632 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
36633 if(!isWasmInitialized) {
36634 throw new Error("initializeWasm() must be awaited first!");
36636 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
36637 return nativeResponseValue;
36639 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
36641 export function SignedRawInvoice_into_parts(this_arg: bigint): bigint {
36642 if(!isWasmInitialized) {
36643 throw new Error("initializeWasm() must be awaited first!");
36645 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
36646 return nativeResponseValue;
36648 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
36650 export function SignedRawInvoice_raw_invoice(this_arg: bigint): bigint {
36651 if(!isWasmInitialized) {
36652 throw new Error("initializeWasm() must be awaited first!");
36654 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
36655 return nativeResponseValue;
36657 // MUST_USE_RES const uint8_t (*SignedRawInvoice_signable_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
36659 export function SignedRawInvoice_signable_hash(this_arg: bigint): number {
36660 if(!isWasmInitialized) {
36661 throw new Error("initializeWasm() must be awaited first!");
36663 const nativeResponseValue = wasm.TS_SignedRawInvoice_signable_hash(this_arg);
36664 return nativeResponseValue;
36666 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
36668 export function SignedRawInvoice_signature(this_arg: bigint): bigint {
36669 if(!isWasmInitialized) {
36670 throw new Error("initializeWasm() must be awaited first!");
36672 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
36673 return nativeResponseValue;
36675 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
36677 export function SignedRawInvoice_recover_payee_pub_key(this_arg: bigint): bigint {
36678 if(!isWasmInitialized) {
36679 throw new Error("initializeWasm() must be awaited first!");
36681 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
36682 return nativeResponseValue;
36684 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
36686 export function SignedRawInvoice_check_signature(this_arg: bigint): boolean {
36687 if(!isWasmInitialized) {
36688 throw new Error("initializeWasm() must be awaited first!");
36690 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
36691 return nativeResponseValue;
36693 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_signable_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36695 export function RawInvoice_signable_hash(this_arg: bigint): number {
36696 if(!isWasmInitialized) {
36697 throw new Error("initializeWasm() must be awaited first!");
36699 const nativeResponseValue = wasm.TS_RawInvoice_signable_hash(this_arg);
36700 return nativeResponseValue;
36702 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36704 export function RawInvoice_payment_hash(this_arg: bigint): bigint {
36705 if(!isWasmInitialized) {
36706 throw new Error("initializeWasm() must be awaited first!");
36708 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
36709 return nativeResponseValue;
36711 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36713 export function RawInvoice_description(this_arg: bigint): bigint {
36714 if(!isWasmInitialized) {
36715 throw new Error("initializeWasm() must be awaited first!");
36717 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
36718 return nativeResponseValue;
36720 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36722 export function RawInvoice_payee_pub_key(this_arg: bigint): bigint {
36723 if(!isWasmInitialized) {
36724 throw new Error("initializeWasm() must be awaited first!");
36726 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
36727 return nativeResponseValue;
36729 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36731 export function RawInvoice_description_hash(this_arg: bigint): bigint {
36732 if(!isWasmInitialized) {
36733 throw new Error("initializeWasm() must be awaited first!");
36735 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
36736 return nativeResponseValue;
36738 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36740 export function RawInvoice_expiry_time(this_arg: bigint): bigint {
36741 if(!isWasmInitialized) {
36742 throw new Error("initializeWasm() must be awaited first!");
36744 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
36745 return nativeResponseValue;
36747 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36749 export function RawInvoice_min_final_cltv_expiry(this_arg: bigint): bigint {
36750 if(!isWasmInitialized) {
36751 throw new Error("initializeWasm() must be awaited first!");
36753 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
36754 return nativeResponseValue;
36756 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36758 export function RawInvoice_payment_secret(this_arg: bigint): number {
36759 if(!isWasmInitialized) {
36760 throw new Error("initializeWasm() must be awaited first!");
36762 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
36763 return nativeResponseValue;
36765 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36767 export function RawInvoice_features(this_arg: bigint): bigint {
36768 if(!isWasmInitialized) {
36769 throw new Error("initializeWasm() must be awaited first!");
36771 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
36772 return nativeResponseValue;
36774 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36776 export function RawInvoice_private_routes(this_arg: bigint): number {
36777 if(!isWasmInitialized) {
36778 throw new Error("initializeWasm() must be awaited first!");
36780 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
36781 return nativeResponseValue;
36783 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36785 export function RawInvoice_amount_pico_btc(this_arg: bigint): bigint {
36786 if(!isWasmInitialized) {
36787 throw new Error("initializeWasm() must be awaited first!");
36789 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
36790 return nativeResponseValue;
36792 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
36794 export function RawInvoice_currency(this_arg: bigint): Currency {
36795 if(!isWasmInitialized) {
36796 throw new Error("initializeWasm() must be awaited first!");
36798 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
36799 return nativeResponseValue;
36801 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
36803 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
36804 if(!isWasmInitialized) {
36805 throw new Error("initializeWasm() must be awaited first!");
36807 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
36808 return nativeResponseValue;
36810 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
36812 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
36813 if(!isWasmInitialized) {
36814 throw new Error("initializeWasm() must be awaited first!");
36816 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
36817 return nativeResponseValue;
36819 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
36821 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
36822 if(!isWasmInitialized) {
36823 throw new Error("initializeWasm() must be awaited first!");
36825 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
36826 return nativeResponseValue;
36828 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
36830 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
36831 if(!isWasmInitialized) {
36832 throw new Error("initializeWasm() must be awaited first!");
36834 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
36835 return nativeResponseValue;
36837 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
36839 export function Invoice_into_signed_raw(this_arg: bigint): bigint {
36840 if(!isWasmInitialized) {
36841 throw new Error("initializeWasm() must be awaited first!");
36843 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
36844 return nativeResponseValue;
36846 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
36848 export function Invoice_check_signature(this_arg: bigint): bigint {
36849 if(!isWasmInitialized) {
36850 throw new Error("initializeWasm() must be awaited first!");
36852 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
36853 return nativeResponseValue;
36855 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
36857 export function Invoice_from_signed(signed_invoice: bigint): bigint {
36858 if(!isWasmInitialized) {
36859 throw new Error("initializeWasm() must be awaited first!");
36861 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
36862 return nativeResponseValue;
36864 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
36866 export function Invoice_duration_since_epoch(this_arg: bigint): bigint {
36867 if(!isWasmInitialized) {
36868 throw new Error("initializeWasm() must be awaited first!");
36870 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
36871 return nativeResponseValue;
36873 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
36875 export function Invoice_payment_hash(this_arg: bigint): number {
36876 if(!isWasmInitialized) {
36877 throw new Error("initializeWasm() must be awaited first!");
36879 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
36880 return nativeResponseValue;
36882 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
36884 export function Invoice_payee_pub_key(this_arg: bigint): number {
36885 if(!isWasmInitialized) {
36886 throw new Error("initializeWasm() must be awaited first!");
36888 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
36889 return nativeResponseValue;
36891 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
36893 export function Invoice_payment_secret(this_arg: bigint): number {
36894 if(!isWasmInitialized) {
36895 throw new Error("initializeWasm() must be awaited first!");
36897 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
36898 return nativeResponseValue;
36900 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
36902 export function Invoice_features(this_arg: bigint): bigint {
36903 if(!isWasmInitialized) {
36904 throw new Error("initializeWasm() must be awaited first!");
36906 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
36907 return nativeResponseValue;
36909 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
36911 export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
36912 if(!isWasmInitialized) {
36913 throw new Error("initializeWasm() must be awaited first!");
36915 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
36916 return nativeResponseValue;
36918 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
36920 export function Invoice_expiry_time(this_arg: bigint): bigint {
36921 if(!isWasmInitialized) {
36922 throw new Error("initializeWasm() must be awaited first!");
36924 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
36925 return nativeResponseValue;
36927 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
36929 export function Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
36930 if(!isWasmInitialized) {
36931 throw new Error("initializeWasm() must be awaited first!");
36933 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
36934 return nativeResponseValue;
36936 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
36938 export function Invoice_min_final_cltv_expiry(this_arg: bigint): bigint {
36939 if(!isWasmInitialized) {
36940 throw new Error("initializeWasm() must be awaited first!");
36942 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
36943 return nativeResponseValue;
36945 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
36947 export function Invoice_private_routes(this_arg: bigint): number {
36948 if(!isWasmInitialized) {
36949 throw new Error("initializeWasm() must be awaited first!");
36951 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
36952 return nativeResponseValue;
36954 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
36956 export function Invoice_route_hints(this_arg: bigint): number {
36957 if(!isWasmInitialized) {
36958 throw new Error("initializeWasm() must be awaited first!");
36960 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
36961 return nativeResponseValue;
36963 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
36965 export function Invoice_currency(this_arg: bigint): Currency {
36966 if(!isWasmInitialized) {
36967 throw new Error("initializeWasm() must be awaited first!");
36969 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
36970 return nativeResponseValue;
36972 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
36974 export function Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
36975 if(!isWasmInitialized) {
36976 throw new Error("initializeWasm() must be awaited first!");
36978 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
36979 return nativeResponseValue;
36981 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
36983 export function Description_new(description: number): bigint {
36984 if(!isWasmInitialized) {
36985 throw new Error("initializeWasm() must be awaited first!");
36987 const nativeResponseValue = wasm.TS_Description_new(description);
36988 return nativeResponseValue;
36990 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
36992 export function Description_into_inner(this_arg: bigint): number {
36993 if(!isWasmInitialized) {
36994 throw new Error("initializeWasm() must be awaited first!");
36996 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
36997 return nativeResponseValue;
36999 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
37001 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
37002 if(!isWasmInitialized) {
37003 throw new Error("initializeWasm() must be awaited first!");
37005 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
37006 return nativeResponseValue;
37008 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
37010 export function ExpiryTime_from_duration(duration: bigint): bigint {
37011 if(!isWasmInitialized) {
37012 throw new Error("initializeWasm() must be awaited first!");
37014 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
37015 return nativeResponseValue;
37017 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
37019 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
37020 if(!isWasmInitialized) {
37021 throw new Error("initializeWasm() must be awaited first!");
37023 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
37024 return nativeResponseValue;
37026 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
37028 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
37029 if(!isWasmInitialized) {
37030 throw new Error("initializeWasm() must be awaited first!");
37032 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
37033 return nativeResponseValue;
37035 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
37037 export function PrivateRoute_new(hops: bigint): bigint {
37038 if(!isWasmInitialized) {
37039 throw new Error("initializeWasm() must be awaited first!");
37041 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
37042 return nativeResponseValue;
37044 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
37046 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
37047 if(!isWasmInitialized) {
37048 throw new Error("initializeWasm() must be awaited first!");
37050 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
37051 return nativeResponseValue;
37053 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
37055 export function CreationError_clone(orig: bigint): CreationError {
37056 if(!isWasmInitialized) {
37057 throw new Error("initializeWasm() must be awaited first!");
37059 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
37060 return nativeResponseValue;
37062 // enum LDKCreationError CreationError_description_too_long(void);
37064 export function CreationError_description_too_long(): CreationError {
37065 if(!isWasmInitialized) {
37066 throw new Error("initializeWasm() must be awaited first!");
37068 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
37069 return nativeResponseValue;
37071 // enum LDKCreationError CreationError_route_too_long(void);
37073 export function CreationError_route_too_long(): CreationError {
37074 if(!isWasmInitialized) {
37075 throw new Error("initializeWasm() must be awaited first!");
37077 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
37078 return nativeResponseValue;
37080 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
37082 export function CreationError_timestamp_out_of_bounds(): CreationError {
37083 if(!isWasmInitialized) {
37084 throw new Error("initializeWasm() must be awaited first!");
37086 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
37087 return nativeResponseValue;
37089 // enum LDKCreationError CreationError_invalid_amount(void);
37091 export function CreationError_invalid_amount(): CreationError {
37092 if(!isWasmInitialized) {
37093 throw new Error("initializeWasm() must be awaited first!");
37095 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
37096 return nativeResponseValue;
37098 // enum LDKCreationError CreationError_missing_route_hints(void);
37100 export function CreationError_missing_route_hints(): CreationError {
37101 if(!isWasmInitialized) {
37102 throw new Error("initializeWasm() must be awaited first!");
37104 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
37105 return nativeResponseValue;
37107 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
37109 export function CreationError_eq(a: bigint, b: bigint): boolean {
37110 if(!isWasmInitialized) {
37111 throw new Error("initializeWasm() must be awaited first!");
37113 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
37114 return nativeResponseValue;
37116 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
37118 export function CreationError_to_str(o: bigint): number {
37119 if(!isWasmInitialized) {
37120 throw new Error("initializeWasm() must be awaited first!");
37122 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
37123 return nativeResponseValue;
37125 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
37127 export function SemanticError_clone(orig: bigint): SemanticError {
37128 if(!isWasmInitialized) {
37129 throw new Error("initializeWasm() must be awaited first!");
37131 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
37132 return nativeResponseValue;
37134 // enum LDKSemanticError SemanticError_no_payment_hash(void);
37136 export function SemanticError_no_payment_hash(): SemanticError {
37137 if(!isWasmInitialized) {
37138 throw new Error("initializeWasm() must be awaited first!");
37140 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
37141 return nativeResponseValue;
37143 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
37145 export function SemanticError_multiple_payment_hashes(): SemanticError {
37146 if(!isWasmInitialized) {
37147 throw new Error("initializeWasm() must be awaited first!");
37149 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
37150 return nativeResponseValue;
37152 // enum LDKSemanticError SemanticError_no_description(void);
37154 export function SemanticError_no_description(): SemanticError {
37155 if(!isWasmInitialized) {
37156 throw new Error("initializeWasm() must be awaited first!");
37158 const nativeResponseValue = wasm.TS_SemanticError_no_description();
37159 return nativeResponseValue;
37161 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
37163 export function SemanticError_multiple_descriptions(): SemanticError {
37164 if(!isWasmInitialized) {
37165 throw new Error("initializeWasm() must be awaited first!");
37167 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
37168 return nativeResponseValue;
37170 // enum LDKSemanticError SemanticError_no_payment_secret(void);
37172 export function SemanticError_no_payment_secret(): SemanticError {
37173 if(!isWasmInitialized) {
37174 throw new Error("initializeWasm() must be awaited first!");
37176 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
37177 return nativeResponseValue;
37179 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
37181 export function SemanticError_multiple_payment_secrets(): SemanticError {
37182 if(!isWasmInitialized) {
37183 throw new Error("initializeWasm() must be awaited first!");
37185 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
37186 return nativeResponseValue;
37188 // enum LDKSemanticError SemanticError_invalid_features(void);
37190 export function SemanticError_invalid_features(): SemanticError {
37191 if(!isWasmInitialized) {
37192 throw new Error("initializeWasm() must be awaited first!");
37194 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
37195 return nativeResponseValue;
37197 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
37199 export function SemanticError_invalid_recovery_id(): SemanticError {
37200 if(!isWasmInitialized) {
37201 throw new Error("initializeWasm() must be awaited first!");
37203 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
37204 return nativeResponseValue;
37206 // enum LDKSemanticError SemanticError_invalid_signature(void);
37208 export function SemanticError_invalid_signature(): SemanticError {
37209 if(!isWasmInitialized) {
37210 throw new Error("initializeWasm() must be awaited first!");
37212 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
37213 return nativeResponseValue;
37215 // enum LDKSemanticError SemanticError_imprecise_amount(void);
37217 export function SemanticError_imprecise_amount(): SemanticError {
37218 if(!isWasmInitialized) {
37219 throw new Error("initializeWasm() must be awaited first!");
37221 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
37222 return nativeResponseValue;
37224 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
37226 export function SemanticError_eq(a: bigint, b: bigint): boolean {
37227 if(!isWasmInitialized) {
37228 throw new Error("initializeWasm() must be awaited first!");
37230 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
37231 return nativeResponseValue;
37233 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
37235 export function SemanticError_to_str(o: bigint): number {
37236 if(!isWasmInitialized) {
37237 throw new Error("initializeWasm() must be awaited first!");
37239 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
37240 return nativeResponseValue;
37242 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
37244 export function SignOrCreationError_free(this_ptr: bigint): void {
37245 if(!isWasmInitialized) {
37246 throw new Error("initializeWasm() must be awaited first!");
37248 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
37249 // debug statements here
37251 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
37253 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
37254 if(!isWasmInitialized) {
37255 throw new Error("initializeWasm() must be awaited first!");
37257 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
37258 return nativeResponseValue;
37260 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
37262 export function SignOrCreationError_clone(orig: bigint): bigint {
37263 if(!isWasmInitialized) {
37264 throw new Error("initializeWasm() must be awaited first!");
37266 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
37267 return nativeResponseValue;
37269 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
37271 export function SignOrCreationError_sign_error(): bigint {
37272 if(!isWasmInitialized) {
37273 throw new Error("initializeWasm() must be awaited first!");
37275 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
37276 return nativeResponseValue;
37278 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
37280 export function SignOrCreationError_creation_error(a: CreationError): bigint {
37281 if(!isWasmInitialized) {
37282 throw new Error("initializeWasm() must be awaited first!");
37284 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
37285 return nativeResponseValue;
37287 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
37289 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
37290 if(!isWasmInitialized) {
37291 throw new Error("initializeWasm() must be awaited first!");
37293 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
37294 return nativeResponseValue;
37296 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
37298 export function SignOrCreationError_to_str(o: bigint): number {
37299 if(!isWasmInitialized) {
37300 throw new Error("initializeWasm() must be awaited first!");
37302 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
37303 return nativeResponseValue;
37305 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
37307 export function InvoicePayer_free(this_obj: bigint): void {
37308 if(!isWasmInitialized) {
37309 throw new Error("initializeWasm() must be awaited first!");
37311 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
37312 // debug statements here
37314 // void Payer_free(struct LDKPayer this_ptr);
37316 export function Payer_free(this_ptr: bigint): void {
37317 if(!isWasmInitialized) {
37318 throw new Error("initializeWasm() must be awaited first!");
37320 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
37321 // debug statements here
37323 // void Retry_free(struct LDKRetry this_ptr);
37325 export function Retry_free(this_ptr: bigint): void {
37326 if(!isWasmInitialized) {
37327 throw new Error("initializeWasm() must be awaited first!");
37329 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
37330 // debug statements here
37332 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
37334 export function Retry_clone_ptr(arg: bigint): bigint {
37335 if(!isWasmInitialized) {
37336 throw new Error("initializeWasm() must be awaited first!");
37338 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
37339 return nativeResponseValue;
37341 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
37343 export function Retry_clone(orig: bigint): bigint {
37344 if(!isWasmInitialized) {
37345 throw new Error("initializeWasm() must be awaited first!");
37347 const nativeResponseValue = wasm.TS_Retry_clone(orig);
37348 return nativeResponseValue;
37350 // struct LDKRetry Retry_attempts(uintptr_t a);
37352 export function Retry_attempts(a: number): bigint {
37353 if(!isWasmInitialized) {
37354 throw new Error("initializeWasm() must be awaited first!");
37356 const nativeResponseValue = wasm.TS_Retry_attempts(a);
37357 return nativeResponseValue;
37359 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
37361 export function Retry_eq(a: bigint, b: bigint): boolean {
37362 if(!isWasmInitialized) {
37363 throw new Error("initializeWasm() must be awaited first!");
37365 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
37366 return nativeResponseValue;
37368 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
37370 export function Retry_hash(o: bigint): bigint {
37371 if(!isWasmInitialized) {
37372 throw new Error("initializeWasm() must be awaited first!");
37374 const nativeResponseValue = wasm.TS_Retry_hash(o);
37375 return nativeResponseValue;
37377 // void PaymentError_free(struct LDKPaymentError this_ptr);
37379 export function PaymentError_free(this_ptr: bigint): void {
37380 if(!isWasmInitialized) {
37381 throw new Error("initializeWasm() must be awaited first!");
37383 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
37384 // debug statements here
37386 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
37388 export function PaymentError_clone_ptr(arg: bigint): bigint {
37389 if(!isWasmInitialized) {
37390 throw new Error("initializeWasm() must be awaited first!");
37392 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
37393 return nativeResponseValue;
37395 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
37397 export function PaymentError_clone(orig: bigint): bigint {
37398 if(!isWasmInitialized) {
37399 throw new Error("initializeWasm() must be awaited first!");
37401 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
37402 return nativeResponseValue;
37404 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
37406 export function PaymentError_invoice(a: number): bigint {
37407 if(!isWasmInitialized) {
37408 throw new Error("initializeWasm() must be awaited first!");
37410 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
37411 return nativeResponseValue;
37413 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
37415 export function PaymentError_routing(a: bigint): bigint {
37416 if(!isWasmInitialized) {
37417 throw new Error("initializeWasm() must be awaited first!");
37419 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
37420 return nativeResponseValue;
37422 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
37424 export function PaymentError_sending(a: bigint): bigint {
37425 if(!isWasmInitialized) {
37426 throw new Error("initializeWasm() must be awaited first!");
37428 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
37429 return nativeResponseValue;
37431 // MUST_USE_RES struct LDKInvoicePayer InvoicePayer_new(struct LDKPayer payer, struct LDKRouter router, struct LDKLogger logger, struct LDKEventHandler event_handler, struct LDKRetry retry);
37433 export function InvoicePayer_new(payer: bigint, router: bigint, logger: bigint, event_handler: bigint, retry: bigint): bigint {
37434 if(!isWasmInitialized) {
37435 throw new Error("initializeWasm() must be awaited first!");
37437 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, logger, event_handler, retry);
37438 return nativeResponseValue;
37440 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
37442 export function InvoicePayer_pay_invoice(this_arg: bigint, invoice: bigint): bigint {
37443 if(!isWasmInitialized) {
37444 throw new Error("initializeWasm() must be awaited first!");
37446 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
37447 return nativeResponseValue;
37449 // MUST_USE_RES struct LDKCResult_NonePaymentErrorZ InvoicePayer_pay_invoice_with_id(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice, struct LDKThirtyTwoBytes payment_id);
37451 export function InvoicePayer_pay_invoice_with_id(this_arg: bigint, invoice: bigint, payment_id: number): bigint {
37452 if(!isWasmInitialized) {
37453 throw new Error("initializeWasm() must be awaited first!");
37455 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice_with_id(this_arg, invoice, payment_id);
37456 return nativeResponseValue;
37458 // 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);
37460 export function InvoicePayer_pay_zero_value_invoice(this_arg: bigint, invoice: bigint, amount_msats: bigint): bigint {
37461 if(!isWasmInitialized) {
37462 throw new Error("initializeWasm() must be awaited first!");
37464 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
37465 return nativeResponseValue;
37467 // MUST_USE_RES struct LDKCResult_NonePaymentErrorZ InvoicePayer_pay_zero_value_invoice_with_id(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id);
37469 export function InvoicePayer_pay_zero_value_invoice_with_id(this_arg: bigint, invoice: bigint, amount_msats: bigint, payment_id: number): bigint {
37470 if(!isWasmInitialized) {
37471 throw new Error("initializeWasm() must be awaited first!");
37473 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice_with_id(this_arg, invoice, amount_msats, payment_id);
37474 return nativeResponseValue;
37476 // 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);
37478 export function InvoicePayer_pay_pubkey(this_arg: bigint, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): bigint {
37479 if(!isWasmInitialized) {
37480 throw new Error("initializeWasm() must be awaited first!");
37482 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
37483 return nativeResponseValue;
37485 // MUST_USE_RES struct LDKCResult_NonePaymentErrorZ InvoicePayer_pay_pubkey_with_id(const struct LDKInvoicePayer *NONNULL_PTR this_arg, struct LDKPublicKey pubkey, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id, uint64_t amount_msats, uint32_t final_cltv_expiry_delta);
37487 export function InvoicePayer_pay_pubkey_with_id(this_arg: bigint, pubkey: number, payment_preimage: number, payment_id: number, amount_msats: bigint, final_cltv_expiry_delta: number): bigint {
37488 if(!isWasmInitialized) {
37489 throw new Error("initializeWasm() must be awaited first!");
37491 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey_with_id(this_arg, pubkey, payment_preimage, payment_id, amount_msats, final_cltv_expiry_delta);
37492 return nativeResponseValue;
37494 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
37496 export function InvoicePayer_remove_cached_payment(this_arg: bigint, payment_hash: number): void {
37497 if(!isWasmInitialized) {
37498 throw new Error("initializeWasm() must be awaited first!");
37500 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
37501 // debug statements here
37503 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
37505 export function InvoicePayer_as_EventHandler(this_arg: bigint): bigint {
37506 if(!isWasmInitialized) {
37507 throw new Error("initializeWasm() must be awaited first!");
37509 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
37510 return nativeResponseValue;
37512 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
37514 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, logger: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
37515 if(!isWasmInitialized) {
37516 throw new Error("initializeWasm() must be awaited first!");
37518 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, keys_manager, logger, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs);
37519 return nativeResponseValue;
37521 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
37523 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
37524 if(!isWasmInitialized) {
37525 throw new Error("initializeWasm() must be awaited first!");
37527 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs);
37528 return nativeResponseValue;
37530 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs, struct LDKThirtyTwoBytes payment_hash);
37532 export function create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager: bigint, keys_manager: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, payment_hash: number): bigint {
37533 if(!isWasmInitialized) {
37534 throw new Error("initializeWasm() must be awaited first!");
37536 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager, keys_manager, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, payment_hash);
37537 return nativeResponseValue;
37539 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
37541 export function ChannelManager_as_Payer(this_arg: bigint): bigint {
37542 if(!isWasmInitialized) {
37543 throw new Error("initializeWasm() must be awaited first!");
37545 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
37546 return nativeResponseValue;
37548 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
37550 export function SiPrefix_from_str(s: number): bigint {
37551 if(!isWasmInitialized) {
37552 throw new Error("initializeWasm() must be awaited first!");
37554 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
37555 return nativeResponseValue;
37557 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
37559 export function Invoice_from_str(s: number): bigint {
37560 if(!isWasmInitialized) {
37561 throw new Error("initializeWasm() must be awaited first!");
37563 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
37564 return nativeResponseValue;
37566 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
37568 export function SignedRawInvoice_from_str(s: number): bigint {
37569 if(!isWasmInitialized) {
37570 throw new Error("initializeWasm() must be awaited first!");
37572 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
37573 return nativeResponseValue;
37575 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
37577 export function ParseError_to_str(o: bigint): number {
37578 if(!isWasmInitialized) {
37579 throw new Error("initializeWasm() must be awaited first!");
37581 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
37582 return nativeResponseValue;
37584 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
37586 export function ParseOrSemanticError_to_str(o: bigint): number {
37587 if(!isWasmInitialized) {
37588 throw new Error("initializeWasm() must be awaited first!");
37590 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
37591 return nativeResponseValue;
37593 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
37595 export function Invoice_to_str(o: bigint): number {
37596 if(!isWasmInitialized) {
37597 throw new Error("initializeWasm() must be awaited first!");
37599 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
37600 return nativeResponseValue;
37602 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
37604 export function SignedRawInvoice_to_str(o: bigint): number {
37605 if(!isWasmInitialized) {
37606 throw new Error("initializeWasm() must be awaited first!");
37608 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
37609 return nativeResponseValue;
37611 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
37613 export function Currency_to_str(o: bigint): number {
37614 if(!isWasmInitialized) {
37615 throw new Error("initializeWasm() must be awaited first!");
37617 const nativeResponseValue = wasm.TS_Currency_to_str(o);
37618 return nativeResponseValue;
37620 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
37622 export function SiPrefix_to_str(o: bigint): number {
37623 if(!isWasmInitialized) {
37624 throw new Error("initializeWasm() must be awaited first!");
37626 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
37627 return nativeResponseValue;
37631 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) {
37632 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
37633 if (weak == null || weak == undefined) {
37634 console.error("Got function call on unknown/free'd JS object!");
37635 throw new Error("Got function call on unknown/free'd JS object!");
37637 const obj = weak.deref();
37638 if (obj == null || obj == undefined) {
37639 console.error("Got function call on GC'd JS object!");
37640 throw new Error("Got function call on GC'd JS object!");
37644 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
37645 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
37646 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
37647 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
37648 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
37649 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
37650 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
37651 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
37652 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
37653 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
37654 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
37655 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
37656 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
37657 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
37658 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
37659 case 15: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
37660 case 16: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
37661 case 17: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
37662 case 18: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
37663 case 19: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
37664 case 20: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
37665 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
37666 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
37667 case 23: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
37668 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
37669 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
37670 case 26: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
37671 case 27: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
37672 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
37673 case 29: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
37674 case 30: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
37675 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
37676 case 32: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
37677 case 33: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
37678 case 34: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
37679 case 35: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
37680 case 36: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
37681 case 37: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
37682 case 38: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
37683 case 39: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
37684 case 40: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
37685 case 41: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
37686 case 42: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
37687 case 43: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
37688 case 44: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
37689 case 45: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
37690 case 46: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
37691 case 47: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
37692 case 48: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
37693 case 49: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
37694 case 50: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
37695 case 51: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
37696 case 52: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
37697 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
37698 case 54: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
37699 case 55: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
37700 case 56: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
37701 case 57: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
37702 case 58: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
37703 case 59: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
37704 case 60: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
37705 case 61: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
37706 case 62: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
37707 case 63: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
37708 case 64: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
37709 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
37710 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
37711 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
37712 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
37713 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
37714 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
37715 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
37716 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
37717 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
37718 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
37719 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
37720 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
37721 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
37722 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
37723 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
37724 case 80: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
37725 case 81: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
37726 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
37727 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
37728 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
37729 case 85: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
37730 case 86: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
37731 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
37732 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
37733 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
37734 case 90: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
37735 case 91: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
37736 case 92: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
37737 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
37738 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
37739 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
37740 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
37741 case 97: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
37742 case 98: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
37743 case 99: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
37744 case 100: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
37745 case 101: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
37746 case 102: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
37747 case 103: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
37748 case 104: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
37749 case 105: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
37750 case 106: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
37751 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
37752 case 108: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
37753 case 109: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
37754 case 110: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
37755 case 111: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
37756 case 112: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
37757 case 113: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
37758 case 114: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
37759 case 115: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_failed"); break;
37760 case 116: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_path_successful"); break;
37761 case 117: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_successful"); break;
37762 case 118: fn = Object.getOwnPropertyDescriptor(obj, "notify_payment_probe_failed"); break;
37763 case 119: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
37764 case 120: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
37765 case 121: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
37766 case 122: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
37767 case 123: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
37768 case 124: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
37769 case 125: fn = Object.getOwnPropertyDescriptor(obj, "inflight_htlcs"); break;
37771 console.error("Got unknown function call from C!");
37772 throw new Error("Got unknown function call from C!");
37774 if (fn == null || fn == undefined) {
37775 console.error("Got function call on incorrect JS object!");
37776 throw new Error("Got function call on incorrect JS object!");
37778 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
37779 if (ret === undefined || ret === null) return BigInt(0);
37780 return BigInt(ret);