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", "bbbbbu",
93 "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uubbuu", "uububu", "ububuu", "uuuubu"];
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 encodeUint16Array (inputArray: Uint16Array|Array<number>|null): number {
153 if (inputArray == null) return 0;
154 const cArrayPointer = wasm.TS_malloc((inputArray.length + 4) * 2);
155 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
156 arrayLengthView[0] = BigInt(inputArray.length);
157 const arrayMemoryView = new Uint16Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
158 arrayMemoryView.set(inputArray);
159 return cArrayPointer;
162 export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
163 if (inputArray == null) return 0;
164 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
165 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
166 arrayLengthView[0] = BigInt(inputArray.length);
167 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
168 arrayMemoryView.set(inputArray);
169 return cArrayPointer;
172 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
173 if (inputArray == null) return 0;
174 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
175 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
176 arrayMemoryView[0] = BigInt(inputArray.length);
177 arrayMemoryView.set(inputArray, 1);
178 return cArrayPointer;
182 export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
183 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
188 export function check_16_arr_len(arr: Uint16Array|null, len: number): Uint16Array|null {
189 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
194 export function getArrayLength(arrayPointer: number): number {
195 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
196 const len = arraySizeViewer[0]!;
197 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
198 return Number(len % (2n ** 32n));
201 export function decodeUint128 (arrayPointer: number, free = true): bigint {
202 const arraySize = getArrayLength(arrayPointer);
203 if (arraySize != 16) throw "Need 16 bytes for a uint128";
204 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
206 for (var i = 0; i < 16; i++) {
208 val |= BigInt(actualArrayViewer[i]!);
211 wasm.TS_free(arrayPointer);
216 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
217 const arraySize = getArrayLength(arrayPointer);
218 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
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 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
222 const actualArray = actualArrayViewer.slice(0, arraySize);
224 wasm.TS_free(arrayPointer);
229 export function decodeUint16Array (arrayPointer: number, free = true): Uint16Array {
230 const arraySize = getArrayLength(arrayPointer);
231 const actualArrayViewer = new Uint16Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
232 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
233 // will free the underlying memory when it becomes unreachable instead of copying here.
234 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
235 const actualArray = actualArrayViewer.slice(0, arraySize);
237 wasm.TS_free(arrayPointer);
242 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
243 const arraySize = getArrayLength(arrayPointer);
244 const actualArrayViewer = new BigUint64Array(
245 wasm.memory.buffer, // value
246 arrayPointer + 8, // offset (ignoring length bytes)
247 arraySize // uint32 count
249 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
250 // will free the underlying memory when it becomes unreachable instead of copying here.
251 const actualArray = new Array(arraySize);
252 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
254 wasm.TS_free(arrayPointer);
259 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
262 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
263 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
264 return actualArrayViewer[idx]!;
268 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
269 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
270 return actualArrayViewer[idx]!;
274 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
275 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
276 return actualArrayViewer[idx]!;
281 export function encodeString(str: string): number {
282 const charArray = new TextEncoder().encode(str);
283 return encodeUint8Array(charArray);
287 export function decodeString(stringPointer: number, free = true): string {
288 const arraySize = getArrayLength(stringPointer);
289 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
290 const result = new TextDecoder("utf-8").decode(memoryView);
293 wasm.TS_free(stringPointer);
299 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
300 /* @internal */ export function debugPrintRemainingAllocs() { }
303 * Whether this blinded HTLC is being failed backwards by the introduction node or a blinded node,
304 * which determines the failure message that should be used.
306 export enum BlindedFailure {
308 * This HTLC is being failed backwards by the introduction node, and thus should be failed with
309 [`msgs::UpdateFailHTLC`] and error code `0x8000|0x4000|24`.
311 LDKBlindedFailure_FromIntroductionNode,
313 * This HTLC is being failed backwards by a blinded node within the path, and thus should be
314 failed with [`msgs::UpdateFailMalformedHTLC`] and error code `0x8000|0x4000|24`.
316 LDKBlindedFailure_FromBlindedNode,
321 * Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to
322 * the requirements sections in BOLT #11
324 export enum Bolt11SemanticError {
326 * The invoice is missing the mandatory payment hash
328 LDKBolt11SemanticError_NoPaymentHash,
330 * The invoice has multiple payment hashes which isn't allowed
332 LDKBolt11SemanticError_MultiplePaymentHashes,
334 * No description or description hash are part of the invoice
336 LDKBolt11SemanticError_NoDescription,
338 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
340 LDKBolt11SemanticError_MultipleDescriptions,
342 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
345 LDKBolt11SemanticError_NoPaymentSecret,
347 * The invoice contains multiple payment secrets
349 LDKBolt11SemanticError_MultiplePaymentSecrets,
351 * The invoice's features are invalid
353 LDKBolt11SemanticError_InvalidFeatures,
355 * The recovery id doesn't fit the signature/pub key
357 LDKBolt11SemanticError_InvalidRecoveryId,
359 * The invoice's signature is invalid
361 LDKBolt11SemanticError_InvalidSignature,
363 * The invoice's amount was not a whole number of millisatoshis
365 LDKBolt11SemanticError_ImpreciseAmount,
370 * Error when interpreting a TLV stream as a specific type.
372 export enum Bolt12SemanticError {
374 * The current [`std::time::SystemTime`] is past the offer or invoice's expiration.
376 LDKBolt12SemanticError_AlreadyExpired,
378 * The provided chain hash does not correspond to a supported chain.
380 LDKBolt12SemanticError_UnsupportedChain,
382 * A chain was provided but was not expected.
384 LDKBolt12SemanticError_UnexpectedChain,
386 * An amount was expected but was missing.
388 LDKBolt12SemanticError_MissingAmount,
390 * The amount exceeded the total bitcoin supply.
392 LDKBolt12SemanticError_InvalidAmount,
394 * An amount was provided but was not sufficient in value.
396 LDKBolt12SemanticError_InsufficientAmount,
398 * An amount was provided but was not expected.
400 LDKBolt12SemanticError_UnexpectedAmount,
402 * A currency was provided that is not supported.
404 LDKBolt12SemanticError_UnsupportedCurrency,
406 * A feature was required but is unknown.
408 LDKBolt12SemanticError_UnknownRequiredFeatures,
410 * Features were provided but were not expected.
412 LDKBolt12SemanticError_UnexpectedFeatures,
414 * A required description was not provided.
416 LDKBolt12SemanticError_MissingDescription,
418 * A signing pubkey was not provided.
420 LDKBolt12SemanticError_MissingSigningPubkey,
422 * A signing pubkey was provided but a different one was expected.
424 LDKBolt12SemanticError_InvalidSigningPubkey,
426 * A signing pubkey was provided but was not expected.
428 LDKBolt12SemanticError_UnexpectedSigningPubkey,
430 * A quantity was expected but was missing.
432 LDKBolt12SemanticError_MissingQuantity,
434 * An unsupported quantity was provided.
436 LDKBolt12SemanticError_InvalidQuantity,
438 * A quantity or quantity bounds was provided but was not expected.
440 LDKBolt12SemanticError_UnexpectedQuantity,
442 * Metadata could not be used to verify the offers message.
444 LDKBolt12SemanticError_InvalidMetadata,
446 * Metadata was provided but was not expected.
448 LDKBolt12SemanticError_UnexpectedMetadata,
450 * Payer metadata was expected but was missing.
452 LDKBolt12SemanticError_MissingPayerMetadata,
454 * A payer id was expected but was missing.
456 LDKBolt12SemanticError_MissingPayerId,
458 * The payment id for a refund or request is already in use.
460 LDKBolt12SemanticError_DuplicatePaymentId,
462 * Blinded paths were expected but were missing.
464 LDKBolt12SemanticError_MissingPaths,
466 * Blinded paths were provided but were not expected.
468 LDKBolt12SemanticError_UnexpectedPaths,
470 * The blinded payinfo given does not match the number of blinded path hops.
472 LDKBolt12SemanticError_InvalidPayInfo,
474 * An invoice creation time was expected but was missing.
476 LDKBolt12SemanticError_MissingCreationTime,
478 * An invoice payment hash was expected but was missing.
480 LDKBolt12SemanticError_MissingPaymentHash,
482 * A signature was expected but was missing.
484 LDKBolt12SemanticError_MissingSignature,
489 * An enum which can either contain a or not
491 export enum COption_NoneZ {
493 * When we're in this state, this COption_NoneZ contains a
495 LDKCOption_NoneZ_Some,
497 * When we're in this state, this COption_NoneZ contains nothing
499 LDKCOption_NoneZ_None,
504 * An enum representing the status of a channel monitor update persistence.
506 * These are generally used as the return value for an implementation of [`Persist`] which is used
507 * as the storage layer for a [`ChainMonitor`]. See the docs on [`Persist`] for a high-level
508 * explanation of how to handle different cases.
510 * While `UnrecoverableError` is provided as a failure variant, it is not truly \"handled\" on the
511 * calling side, and generally results in an immediate panic. For those who prefer to avoid
512 * panics, `InProgress` can be used and you can retry the update operation in the background or
515 * Note that channels should generally *not* be force-closed after a persistence failure.
516 * Force-closing with the latest [`ChannelMonitorUpdate`] applied may result in a transaction
517 * being broadcast which can only be spent by the latest [`ChannelMonitor`]! Thus, if the
518 * latest [`ChannelMonitor`] is not durably persisted anywhere and exists only in memory, naively
519 * calling [`ChannelManager::force_close_broadcasting_latest_txn`] *may result in loss of funds*!
521 * [`Persist`]: chainmonitor::Persist
522 * [`ChainMonitor`]: chainmonitor::ChainMonitor
523 * [`ChannelManager::force_close_broadcasting_latest_txn`]: crate::ln::channelmanager::ChannelManager::force_close_broadcasting_latest_txn
525 export enum ChannelMonitorUpdateStatus {
527 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
530 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
531 be available on restart even if the application crashes.
533 LDKChannelMonitorUpdateStatus_Completed,
535 * Indicates that the update will happen asynchronously in the background or that a transient
536 failure occurred which is being retried in the background and will eventually complete.
538 This will \"freeze\" a channel, preventing us from revoking old states or submitting a new
539 commitment transaction to the counterparty. Once the update(s) which are `InProgress` have
540 been completed, a [`MonitorEvent::Completed`] can be used to restore the channel to an
543 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
544 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
545 attempting to claim it on this channel) and those updates must still be persisted.
547 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
548 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
549 monitor update for the same channel.
551 For deployments where a copy of [`ChannelMonitor`]s and other local state are backed up in
552 a remote location (with local copies persisted immediately), it is anticipated that all
553 updates will return [`InProgress`] until the remote copies could be updated.
555 Note that while fully asynchronous persistence of [`ChannelMonitor`] data is generally
556 reliable, this feature is considered beta, and a handful of edge-cases remain. Until the
557 remaining cases are fixed, in rare cases, *using this feature may lead to funds loss*.
559 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
561 LDKChannelMonitorUpdateStatus_InProgress,
563 * Indicates that an update has failed and will not complete at any point in the future.
565 Currently returning this variant will cause LDK to immediately panic to encourage immediate
566 shutdown. In the future this may be updated to disconnect peers and refuse to continue
567 normal operation without a panic.
569 Applications which wish to perform an orderly shutdown after failure should consider
570 returning [`InProgress`] instead and simply shut down without ever marking the update
573 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
575 LDKChannelMonitorUpdateStatus_UnrecoverableError,
580 * Further information on the details of the channel shutdown.
581 * Upon channels being forced closed (i.e. commitment transaction confirmation detected
582 * by `ChainMonitor`), ChannelShutdownState will be set to `ShutdownComplete` or
583 * the channel will be removed shortly.
584 * Also note, that in normal operation, peers could disconnect at any of these states
585 * and require peer re-connection before making progress onto other states
587 export enum ChannelShutdownState {
589 * Channel has not sent or received a shutdown message.
591 LDKChannelShutdownState_NotShuttingDown,
593 * Local node has sent a shutdown message for this channel.
595 LDKChannelShutdownState_ShutdownInitiated,
597 * Shutdown message exchanges have concluded and the channels are in the midst of
598 resolving all existing open HTLCs before closing can continue.
600 LDKChannelShutdownState_ResolvingHTLCs,
602 * All HTLCs have been resolved, nodes are currently negotiating channel close onchain fee rates.
604 LDKChannelShutdownState_NegotiatingClosingFee,
606 * We've successfully negotiated a closing_signed dance. At this point `ChannelManager` is about
609 LDKChannelShutdownState_ShutdownComplete,
614 * An enum that represents the priority at which we want a transaction to confirm used for feerate
617 export enum ConfirmationTarget {
619 * We have some funds available on chain which we need to spend prior to some expiry time at
620 which point our counterparty may be able to steal them. Generally we have in the high tens
621 to low hundreds of blocks to get our transaction on-chain, but we shouldn't risk too low a
622 fee - this should be a relatively high priority feerate.
624 LDKConfirmationTarget_OnChainSweep,
626 * This is the lowest feerate we will allow our channel counterparty to have in an anchor
627 channel in order to close the channel if a channel party goes away.
629 This needs to be sufficient to get into the mempool when the channel needs to
630 be force-closed. Setting too high may result in force-closures if our counterparty attempts
631 to use a lower feerate. Because this is for anchor channels, we can always bump the feerate
632 later; the feerate here only needs to be sufficient to enter the mempool.
634 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
635 is not an estimate which is very easy to calculate because we do not know the future. Using
636 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
637 ensure you can always close the channel. A future change to Bitcoin's P2P network
638 (package relay) may obviate the need for this entirely.
640 LDKConfirmationTarget_MinAllowedAnchorChannelRemoteFee,
642 * The lowest feerate we will allow our channel counterparty to have in a non-anchor channel.
644 This is the feerate on the transaction which we (or our counterparty) will broadcast in
645 order to close the channel if a channel party goes away. Setting this value too high will
646 cause immediate force-closures in order to avoid having an unbroadcastable state.
648 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
649 arbitrary time in the future. Obviously this is not an estimate which is very easy to
650 calculate. This can leave channels subject to being unable to close if feerates rise, and in
651 general you should prefer anchor channels to ensure you can increase the feerate when the
652 transactions need broadcasting.
654 Do note some fee estimators round up to the next full sat/vbyte (ie 250 sats per kw),
655 causing occasional issues with feerate disagreements between an initiator that wants a
656 feerate of 1.1 sat/vbyte and a receiver that wants 1.1 rounded up to 2. If your fee
657 estimator rounds subtracting 250 to your desired feerate here can help avoid this issue.
659 [`ChannelConfig::max_dust_htlc_exposure`]: crate::util::config::ChannelConfig::max_dust_htlc_exposure
661 LDKConfirmationTarget_MinAllowedNonAnchorChannelRemoteFee,
663 * This is the feerate on the transaction which we (or our counterparty) will broadcast in
664 order to close the channel if a channel party goes away.
666 This needs to be sufficient to get into the mempool when the channel needs to
667 be force-closed. Setting too low may result in force-closures. Because this is for anchor
668 channels, it can be a low value as we can always bump the feerate later.
670 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
671 is not an estimate which is very easy to calculate because we do not know the future. Using
672 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
673 ensure you can always close the channel. A future change to Bitcoin's P2P network
674 (package relay) may obviate the need for this entirely.
676 LDKConfirmationTarget_AnchorChannelFee,
678 * Lightning is built around the ability to broadcast a transaction in the future to close our
679 channel and claim all pending funds. In order to do so, non-anchor channels are built with
680 transactions which we need to be able to broadcast at some point in the future.
682 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
683 arbitrary time in the future. Obviously this is not an estimate which is very easy to
684 calculate, so most lightning nodes use some relatively high-priority feerate using the
685 current mempool. This leaves channels subject to being unable to close if feerates rise, and
686 in general you should prefer anchor channels to ensure you can increase the feerate when the
687 transactions need broadcasting.
689 Since this should represent the feerate of a channel close that does not need fee
690 bumping, this is also used as an upper bound for our attempted feerate when doing cooperative
691 closure of any channel.
693 LDKConfirmationTarget_NonAnchorChannelFee,
695 * When cooperatively closing a channel, this is the minimum feerate we will accept.
696 Recommended at least within a day or so worth of blocks.
698 This will also be used when initiating a cooperative close of a channel. When closing a
699 channel you can override this fee by using
700 [`ChannelManager::close_channel_with_feerate_and_script`].
702 [`ChannelManager::close_channel_with_feerate_and_script`]: crate::ln::channelmanager::ChannelManager::close_channel_with_feerate_and_script
704 LDKConfirmationTarget_ChannelCloseMinimum,
706 * The feerate [`OutputSweeper`] will use on transactions spending
707 [`SpendableOutputDescriptor`]s after a channel closure.
709 Generally spending these outputs is safe as long as they eventually confirm, so a value
710 (slightly above) the mempool minimum should suffice. However, as this value will influence
711 how long funds will be unavailable after channel closure, [`FeeEstimator`] implementors
712 might want to choose a higher feerate to regain control over funds faster.
714 [`OutputSweeper`]: crate::util::sweep::OutputSweeper
715 [`SpendableOutputDescriptor`]: crate::sign::SpendableOutputDescriptor
717 LDKConfirmationTarget_OutputSpendingFee,
722 * Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
724 export enum CreationError {
726 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
728 LDKCreationError_DescriptionTooLong,
730 * The specified route has too many hops and can't be encoded
732 LDKCreationError_RouteTooLong,
734 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
736 LDKCreationError_TimestampOutOfBounds,
738 * The supplied millisatoshi amount was greater than the total bitcoin supply.
740 LDKCreationError_InvalidAmount,
742 * Route hints were required for this invoice and were missing. Applies to
745 [phantom invoices]: crate::utils::create_phantom_invoice
747 LDKCreationError_MissingRouteHints,
749 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
751 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
753 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
758 * Enum representing the crypto currencies (or networks) supported by this library
760 export enum Currency {
768 LDKCurrency_BitcoinTestnet,
785 * The side of a channel that is the [`IntroductionNode`] in a [`BlindedPath`]. [BOLT 7] defines
786 * which nodes is which in the [`ChannelAnnouncement`] message.
788 * [BOLT 7]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
789 * [`ChannelAnnouncement`]: crate::ln::msgs::ChannelAnnouncement
791 export enum Direction {
793 * The lesser node id when compared lexicographically in ascending order.
795 LDKDirection_NodeOne,
797 * The greater node id when compared lexicographically in ascending order.
799 LDKDirection_NodeTwo,
804 * Describes the type of HTLC claim as determined by analyzing the witness.
806 export enum HTLCClaim {
808 * Claims an offered output on a commitment transaction through the timeout path.
810 LDKHTLCClaim_OfferedTimeout,
812 * Claims an offered output on a commitment transaction through the success path.
814 LDKHTLCClaim_OfferedPreimage,
816 * Claims an accepted output on a commitment transaction through the timeout path.
818 LDKHTLCClaim_AcceptedTimeout,
820 * Claims an accepted output on a commitment transaction through the success path.
822 LDKHTLCClaim_AcceptedPreimage,
824 * Claims an offered/accepted output on a commitment transaction through the revocation path.
826 LDKHTLCClaim_Revocation,
831 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
833 export enum IOError {
835 LDKIOError_PermissionDenied,
836 LDKIOError_ConnectionRefused,
837 LDKIOError_ConnectionReset,
838 LDKIOError_ConnectionAborted,
839 LDKIOError_NotConnected,
840 LDKIOError_AddrInUse,
841 LDKIOError_AddrNotAvailable,
842 LDKIOError_BrokenPipe,
843 LDKIOError_AlreadyExists,
844 LDKIOError_WouldBlock,
845 LDKIOError_InvalidInput,
846 LDKIOError_InvalidData,
848 LDKIOError_WriteZero,
849 LDKIOError_Interrupted,
851 LDKIOError_UnexpectedEof,
856 * An enum representing the available verbosity levels of the logger.
860 * Designates extremely verbose information, including gossip-induced messages
864 * Designates very low priority, often extremely verbose, information
868 * Designates lower priority information
872 * Designates useful information
876 * Designates hazardous situations
880 * Designates very serious errors
887 * An enum representing the possible Bitcoin or test networks which we can run on
889 export enum Network {
891 * The main Bitcoin blockchain.
895 * The testnet3 blockchain.
899 * A local test blockchain.
903 * A blockchain on which blocks are signed instead of mined.
910 * The reason the payment failed. Used in [`Event::PaymentFailed`].
912 export enum PaymentFailureReason {
914 * The intended recipient rejected our payment.
916 LDKPaymentFailureReason_RecipientRejected,
918 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
920 [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
922 LDKPaymentFailureReason_UserAbandoned,
924 * We exhausted all of our retry attempts while trying to send the payment, or we
925 exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
926 attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
927 have come before this.
929 [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
931 LDKPaymentFailureReason_RetriesExhausted,
933 * The payment expired while retrying, based on the provided
934 [`PaymentParameters::expiry_time`].
936 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
938 LDKPaymentFailureReason_PaymentExpired,
940 * We failed to find a route while retrying the payment.
942 Note that this generally indicates that we've exhausted the available set of possible
943 routes - we tried the payment over a few routes but were not able to find any further
944 candidate routes beyond those.
946 LDKPaymentFailureReason_RouteNotFound,
948 * This error should generally never happen. This likely means that there is a problem with
951 LDKPaymentFailureReason_UnexpectedError,
956 * Specifies the recipient of an invoice.
958 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
961 export enum Recipient {
963 * The invoice should be signed with the local node secret key.
967 * The invoice should be signed with the phantom node secret key. This secret key must be the
968 same for all nodes participating in the [phantom node payment].
970 [phantom node payment]: PhantomKeysManager
972 LDKRecipient_PhantomNode,
977 * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
978 * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
980 * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
981 * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
982 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
984 export enum RetryableSendFailure {
986 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
987 that this error is *not* caused by [`Retry::Timeout`].
989 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
991 LDKRetryableSendFailure_PaymentExpired,
993 * We were unable to find a route to the destination.
995 LDKRetryableSendFailure_RouteNotFound,
997 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
998 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
1000 [`PaymentId`]: crate::ln::channelmanager::PaymentId
1001 [`Event::PaymentSent`]: crate::events::Event::PaymentSent
1002 [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
1004 LDKRetryableSendFailure_DuplicatePayment,
1009 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
1011 export enum Secp256k1Error {
1013 * Signature failed verification
1015 LDKSecp256k1Error_IncorrectSignature,
1017 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
1019 LDKSecp256k1Error_InvalidMessage,
1023 LDKSecp256k1Error_InvalidPublicKey,
1027 LDKSecp256k1Error_InvalidSignature,
1031 LDKSecp256k1Error_InvalidSecretKey,
1033 * Bad shared secret.
1035 LDKSecp256k1Error_InvalidSharedSecret,
1039 LDKSecp256k1Error_InvalidRecoveryId,
1041 * Invalid tweak for add_assign or mul_assign
1043 LDKSecp256k1Error_InvalidTweak,
1045 * Didn't pass enough memory to context creation with preallocated memory
1047 LDKSecp256k1Error_NotEnoughMemory,
1049 * Bad set of public keys.
1051 LDKSecp256k1Error_InvalidPublicKeySum,
1053 * The only valid parity values are 0 or 1.
1055 LDKSecp256k1Error_InvalidParityValue,
1060 * A `short_channel_id` construction error
1062 export enum ShortChannelIdError {
1064 * Block height too high
1066 LDKShortChannelIdError_BlockOverflow,
1070 LDKShortChannelIdError_TxIndexOverflow,
1072 * Vout index too high
1074 LDKShortChannelIdError_VoutIndexOverflow,
1079 * SI prefixes for the human readable part
1081 export enum SiPrefix {
1102 * [`SocketAddress`] error variants
1104 export enum SocketAddressParseError {
1106 * Socket address (IPv4/IPv6) parsing error
1108 LDKSocketAddressParseError_SocketAddrParse,
1110 * Invalid input format
1112 LDKSocketAddressParseError_InvalidInput,
1116 LDKSocketAddressParseError_InvalidPort,
1118 * Invalid onion v3 address
1120 LDKSocketAddressParseError_InvalidOnionV3,
1125 * An error when accessing the chain via [`UtxoLookup`].
1127 export enum UtxoLookupError {
1129 * The requested chain is unknown.
1131 LDKUtxoLookupError_UnknownChain,
1133 * The requested transaction doesn't exist or hasn't confirmed.
1135 LDKUtxoLookupError_UnknownTx,
1138 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
1140 export function BigEndianScalar_get_bytes(thing: bigint): number {
1141 if(!isWasmInitialized) {
1142 throw new Error("initializeWasm() must be awaited first!");
1144 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
1145 return nativeResponseValue;
1147 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
1149 export function BigEndianScalar_free(thing: bigint): void {
1150 if(!isWasmInitialized) {
1151 throw new Error("initializeWasm() must be awaited first!");
1153 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
1154 // debug statements here
1157 export class LDKBech32Error {
1158 protected constructor() {}
1161 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
1162 if(!isWasmInitialized) {
1163 throw new Error("initializeWasm() must be awaited first!");
1165 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
1166 return nativeResponseValue;
1169 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
1170 if(!isWasmInitialized) {
1171 throw new Error("initializeWasm() must be awaited first!");
1173 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
1174 return nativeResponseValue;
1177 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
1178 if(!isWasmInitialized) {
1179 throw new Error("initializeWasm() must be awaited first!");
1181 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
1182 return nativeResponseValue;
1184 // struct LDKRefundMaybeWithDerivedMetadataBuilder CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
1186 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
1187 if(!isWasmInitialized) {
1188 throw new Error("initializeWasm() must be awaited first!");
1190 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(owner);
1191 return nativeResponseValue;
1193 // enum LDKBolt12SemanticError CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
1195 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
1196 if(!isWasmInitialized) {
1197 throw new Error("initializeWasm() must be awaited first!");
1199 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(owner);
1200 return nativeResponseValue;
1202 // struct LDKRefund CResult_RefundBolt12SemanticErrorZ_get_ok(LDKCResult_RefundBolt12SemanticErrorZ *NONNULL_PTR owner);
1204 export function CResult_RefundBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_get_ok(owner);
1209 return nativeResponseValue;
1211 // enum LDKBolt12SemanticError CResult_RefundBolt12SemanticErrorZ_get_err(LDKCResult_RefundBolt12SemanticErrorZ *NONNULL_PTR owner);
1213 export function CResult_RefundBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
1214 if(!isWasmInitialized) {
1215 throw new Error("initializeWasm() must be awaited first!");
1217 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_get_err(owner);
1218 return nativeResponseValue;
1221 export class LDKCOption_u64Z {
1222 protected constructor() {}
1225 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1226 if(!isWasmInitialized) {
1227 throw new Error("initializeWasm() must be awaited first!");
1229 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1230 return nativeResponseValue;
1233 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1234 if(!isWasmInitialized) {
1235 throw new Error("initializeWasm() must be awaited first!");
1237 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1238 return nativeResponseValue;
1240 // struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1242 export function CResult_RefundBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
1243 if(!isWasmInitialized) {
1244 throw new Error("initializeWasm() must be awaited first!");
1246 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_ok(owner);
1247 return nativeResponseValue;
1249 // struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1251 export function CResult_RefundBolt12ParseErrorZ_get_err(owner: bigint): bigint {
1252 if(!isWasmInitialized) {
1253 throw new Error("initializeWasm() must be awaited first!");
1255 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_err(owner);
1256 return nativeResponseValue;
1259 export class LDKRetry {
1260 protected constructor() {}
1263 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
1264 if(!isWasmInitialized) {
1265 throw new Error("initializeWasm() must be awaited first!");
1267 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
1268 return nativeResponseValue;
1271 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
1272 if(!isWasmInitialized) {
1273 throw new Error("initializeWasm() must be awaited first!");
1275 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
1276 return nativeResponseValue;
1279 export class LDKDecodeError {
1280 protected constructor() {}
1283 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
1284 if(!isWasmInitialized) {
1285 throw new Error("initializeWasm() must be awaited first!");
1287 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
1288 return nativeResponseValue;
1291 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1292 if(!isWasmInitialized) {
1293 throw new Error("initializeWasm() must be awaited first!");
1295 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1296 return nativeResponseValue;
1298 // struct LDKRetry CResult_RetryDecodeErrorZ_get_ok(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1300 export function CResult_RetryDecodeErrorZ_get_ok(owner: bigint): bigint {
1301 if(!isWasmInitialized) {
1302 throw new Error("initializeWasm() must be awaited first!");
1304 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_ok(owner);
1305 return nativeResponseValue;
1307 // struct LDKDecodeError CResult_RetryDecodeErrorZ_get_err(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1309 export function CResult_RetryDecodeErrorZ_get_err(owner: bigint): bigint {
1310 if(!isWasmInitialized) {
1311 throw new Error("initializeWasm() must be awaited first!");
1313 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_err(owner);
1314 return nativeResponseValue;
1317 export class LDKAPIError {
1318 protected constructor() {}
1321 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
1322 if(!isWasmInitialized) {
1323 throw new Error("initializeWasm() must be awaited first!");
1325 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
1326 return nativeResponseValue;
1329 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
1330 if(!isWasmInitialized) {
1331 throw new Error("initializeWasm() must be awaited first!");
1333 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
1334 return nativeResponseValue;
1337 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
1338 if(!isWasmInitialized) {
1339 throw new Error("initializeWasm() must be awaited first!");
1341 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
1342 return nativeResponseValue;
1345 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
1346 if(!isWasmInitialized) {
1347 throw new Error("initializeWasm() must be awaited first!");
1349 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
1350 return nativeResponseValue;
1353 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
1354 if(!isWasmInitialized) {
1355 throw new Error("initializeWasm() must be awaited first!");
1357 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
1358 return nativeResponseValue;
1361 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
1362 if(!isWasmInitialized) {
1363 throw new Error("initializeWasm() must be awaited first!");
1365 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
1366 return nativeResponseValue;
1369 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
1370 if(!isWasmInitialized) {
1371 throw new Error("initializeWasm() must be awaited first!");
1373 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
1374 return nativeResponseValue;
1376 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1378 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
1379 if(!isWasmInitialized) {
1380 throw new Error("initializeWasm() must be awaited first!");
1382 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
1383 // debug statements here
1385 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1387 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
1388 if(!isWasmInitialized) {
1389 throw new Error("initializeWasm() must be awaited first!");
1391 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
1392 return nativeResponseValue;
1395 export class LDKCOption_ThirtyTwoBytesZ {
1396 protected constructor() {}
1399 export function LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr: bigint): number {
1400 if(!isWasmInitialized) {
1401 throw new Error("initializeWasm() must be awaited first!");
1403 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr);
1404 return nativeResponseValue;
1407 export function LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr: bigint): number {
1408 if(!isWasmInitialized) {
1409 throw new Error("initializeWasm() must be awaited first!");
1411 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr);
1412 return nativeResponseValue;
1415 export class LDKCOption_CVec_u8ZZ {
1416 protected constructor() {}
1419 export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
1420 if(!isWasmInitialized) {
1421 throw new Error("initializeWasm() must be awaited first!");
1423 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
1424 return nativeResponseValue;
1427 export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
1428 if(!isWasmInitialized) {
1429 throw new Error("initializeWasm() must be awaited first!");
1431 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
1432 return nativeResponseValue;
1434 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1436 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
1437 if(!isWasmInitialized) {
1438 throw new Error("initializeWasm() must be awaited first!");
1440 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
1441 return nativeResponseValue;
1443 // struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1445 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
1446 if(!isWasmInitialized) {
1447 throw new Error("initializeWasm() must be awaited first!");
1449 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
1450 return nativeResponseValue;
1452 // uint64_t C2Tuple_u64CVec_u8ZZ_get_a(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1454 export function C2Tuple_u64CVec_u8ZZ_get_a(owner: bigint): bigint {
1455 if(!isWasmInitialized) {
1456 throw new Error("initializeWasm() must be awaited first!");
1458 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_a(owner);
1459 return nativeResponseValue;
1461 // struct LDKCVec_u8Z C2Tuple_u64CVec_u8ZZ_get_b(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1463 export function C2Tuple_u64CVec_u8ZZ_get_b(owner: bigint): number {
1464 if(!isWasmInitialized) {
1465 throw new Error("initializeWasm() must be awaited first!");
1467 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_b(owner);
1468 return nativeResponseValue;
1470 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsNoneZ_get_ok(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1472 export function CResult_RecipientOnionFieldsNoneZ_get_ok(owner: bigint): bigint {
1473 if(!isWasmInitialized) {
1474 throw new Error("initializeWasm() must be awaited first!");
1476 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_ok(owner);
1477 return nativeResponseValue;
1479 // void CResult_RecipientOnionFieldsNoneZ_get_err(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1481 export function CResult_RecipientOnionFieldsNoneZ_get_err(owner: bigint): void {
1482 if(!isWasmInitialized) {
1483 throw new Error("initializeWasm() must be awaited first!");
1485 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_err(owner);
1486 // debug statements here
1488 // struct LDKUnsignedBolt12Invoice CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_ok(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR owner);
1490 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_ok(owner);
1495 return nativeResponseValue;
1497 // enum LDKBolt12SemanticError CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_err(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR owner);
1499 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
1500 if(!isWasmInitialized) {
1501 throw new Error("initializeWasm() must be awaited first!");
1503 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_get_err(owner);
1504 return nativeResponseValue;
1506 // struct LDKBolt12Invoice CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_ok(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR owner);
1508 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
1509 if(!isWasmInitialized) {
1510 throw new Error("initializeWasm() must be awaited first!");
1512 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_ok(owner);
1513 return nativeResponseValue;
1515 // enum LDKBolt12SemanticError CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_err(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR owner);
1517 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
1518 if(!isWasmInitialized) {
1519 throw new Error("initializeWasm() must be awaited first!");
1521 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_get_err(owner);
1522 return nativeResponseValue;
1524 // struct LDKSchnorrSignature CResult_SchnorrSignatureNoneZ_get_ok(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1526 export function CResult_SchnorrSignatureNoneZ_get_ok(owner: bigint): number {
1527 if(!isWasmInitialized) {
1528 throw new Error("initializeWasm() must be awaited first!");
1530 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_ok(owner);
1531 return nativeResponseValue;
1533 // void CResult_SchnorrSignatureNoneZ_get_err(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1535 export function CResult_SchnorrSignatureNoneZ_get_err(owner: bigint): void {
1536 if(!isWasmInitialized) {
1537 throw new Error("initializeWasm() must be awaited first!");
1539 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_err(owner);
1540 // debug statements here
1543 export class LDKCOption_CVec_ThirtyTwoBytesZZ {
1544 protected constructor() {}
1547 export function LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr: bigint): number {
1548 if(!isWasmInitialized) {
1549 throw new Error("initializeWasm() must be awaited first!");
1551 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr);
1552 return nativeResponseValue;
1555 export function LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr: bigint): number {
1556 if(!isWasmInitialized) {
1557 throw new Error("initializeWasm() must be awaited first!");
1559 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr);
1560 return nativeResponseValue;
1563 export class LDKAmount {
1564 protected constructor() {}
1567 export function LDKAmount_ty_from_ptr(ptr: bigint): number {
1568 if(!isWasmInitialized) {
1569 throw new Error("initializeWasm() must be awaited first!");
1571 const nativeResponseValue = wasm.TS_LDKAmount_ty_from_ptr(ptr);
1572 return nativeResponseValue;
1575 export function LDKAmount_Bitcoin_get_amount_msats(ptr: bigint): bigint {
1576 if(!isWasmInitialized) {
1577 throw new Error("initializeWasm() must be awaited first!");
1579 const nativeResponseValue = wasm.TS_LDKAmount_Bitcoin_get_amount_msats(ptr);
1580 return nativeResponseValue;
1583 export function LDKAmount_Currency_get_iso4217_code(ptr: bigint): number {
1584 if(!isWasmInitialized) {
1585 throw new Error("initializeWasm() must be awaited first!");
1587 const nativeResponseValue = wasm.TS_LDKAmount_Currency_get_iso4217_code(ptr);
1588 return nativeResponseValue;
1591 export function LDKAmount_Currency_get_amount(ptr: bigint): bigint {
1592 if(!isWasmInitialized) {
1593 throw new Error("initializeWasm() must be awaited first!");
1595 const nativeResponseValue = wasm.TS_LDKAmount_Currency_get_amount(ptr);
1596 return nativeResponseValue;
1599 export class LDKCOption_AmountZ {
1600 protected constructor() {}
1603 export function LDKCOption_AmountZ_ty_from_ptr(ptr: bigint): number {
1604 if(!isWasmInitialized) {
1605 throw new Error("initializeWasm() must be awaited first!");
1607 const nativeResponseValue = wasm.TS_LDKCOption_AmountZ_ty_from_ptr(ptr);
1608 return nativeResponseValue;
1611 export function LDKCOption_AmountZ_Some_get_some(ptr: bigint): bigint {
1612 if(!isWasmInitialized) {
1613 throw new Error("initializeWasm() must be awaited first!");
1615 const nativeResponseValue = wasm.TS_LDKCOption_AmountZ_Some_get_some(ptr);
1616 return nativeResponseValue;
1619 export class LDKQuantity {
1620 protected constructor() {}
1623 export function LDKQuantity_ty_from_ptr(ptr: bigint): number {
1624 if(!isWasmInitialized) {
1625 throw new Error("initializeWasm() must be awaited first!");
1627 const nativeResponseValue = wasm.TS_LDKQuantity_ty_from_ptr(ptr);
1628 return nativeResponseValue;
1631 export function LDKQuantity_Bounded_get_bounded(ptr: bigint): bigint {
1632 if(!isWasmInitialized) {
1633 throw new Error("initializeWasm() must be awaited first!");
1635 const nativeResponseValue = wasm.TS_LDKQuantity_Bounded_get_bounded(ptr);
1636 return nativeResponseValue;
1639 export class LDKCOption_QuantityZ {
1640 protected constructor() {}
1643 export function LDKCOption_QuantityZ_ty_from_ptr(ptr: bigint): number {
1644 if(!isWasmInitialized) {
1645 throw new Error("initializeWasm() must be awaited first!");
1647 const nativeResponseValue = wasm.TS_LDKCOption_QuantityZ_ty_from_ptr(ptr);
1648 return nativeResponseValue;
1651 export function LDKCOption_QuantityZ_Some_get_some(ptr: bigint): bigint {
1652 if(!isWasmInitialized) {
1653 throw new Error("initializeWasm() must be awaited first!");
1655 const nativeResponseValue = wasm.TS_LDKCOption_QuantityZ_Some_get_some(ptr);
1656 return nativeResponseValue;
1658 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesNoneZ_get_ok(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1660 export function CResult_ThirtyTwoBytesNoneZ_get_ok(owner: bigint): number {
1661 if(!isWasmInitialized) {
1662 throw new Error("initializeWasm() must be awaited first!");
1664 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_ok(owner);
1665 return nativeResponseValue;
1667 // void CResult_ThirtyTwoBytesNoneZ_get_err(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1669 export function CResult_ThirtyTwoBytesNoneZ_get_err(owner: bigint): void {
1670 if(!isWasmInitialized) {
1671 throw new Error("initializeWasm() must be awaited first!");
1673 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_err(owner);
1674 // debug statements here
1676 // struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1678 export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
1679 if(!isWasmInitialized) {
1680 throw new Error("initializeWasm() must be awaited first!");
1682 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
1683 return nativeResponseValue;
1685 // struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1687 export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
1688 if(!isWasmInitialized) {
1689 throw new Error("initializeWasm() must be awaited first!");
1691 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
1692 return nativeResponseValue;
1694 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1696 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1697 if(!isWasmInitialized) {
1698 throw new Error("initializeWasm() must be awaited first!");
1700 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1701 return nativeResponseValue;
1703 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1705 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1706 if(!isWasmInitialized) {
1707 throw new Error("initializeWasm() must be awaited first!");
1709 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1710 return nativeResponseValue;
1712 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1714 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1719 return nativeResponseValue;
1721 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1723 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1724 if(!isWasmInitialized) {
1725 throw new Error("initializeWasm() must be awaited first!");
1727 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1728 return nativeResponseValue;
1731 export class LDKSpendableOutputDescriptor {
1732 protected constructor() {}
1735 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1736 if(!isWasmInitialized) {
1737 throw new Error("initializeWasm() must be awaited first!");
1739 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1740 return nativeResponseValue;
1743 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1744 if(!isWasmInitialized) {
1745 throw new Error("initializeWasm() must be awaited first!");
1747 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1748 return nativeResponseValue;
1751 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1752 if(!isWasmInitialized) {
1753 throw new Error("initializeWasm() must be awaited first!");
1755 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1756 return nativeResponseValue;
1759 export function LDKSpendableOutputDescriptor_StaticOutput_get_channel_keys_id(ptr: bigint): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_channel_keys_id(ptr);
1764 return nativeResponseValue;
1767 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1768 if(!isWasmInitialized) {
1769 throw new Error("initializeWasm() must be awaited first!");
1771 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1772 return nativeResponseValue;
1775 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1776 if(!isWasmInitialized) {
1777 throw new Error("initializeWasm() must be awaited first!");
1779 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1780 return nativeResponseValue;
1782 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1784 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1785 if(!isWasmInitialized) {
1786 throw new Error("initializeWasm() must be awaited first!");
1788 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
1789 return nativeResponseValue;
1791 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1793 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1794 if(!isWasmInitialized) {
1795 throw new Error("initializeWasm() must be awaited first!");
1797 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
1798 return nativeResponseValue;
1801 export class LDKCOption_u32Z {
1802 protected constructor() {}
1805 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1806 if(!isWasmInitialized) {
1807 throw new Error("initializeWasm() must be awaited first!");
1809 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1810 return nativeResponseValue;
1813 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1814 if(!isWasmInitialized) {
1815 throw new Error("initializeWasm() must be awaited first!");
1817 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1818 return nativeResponseValue;
1820 // struct LDKCVec_u8Z C2Tuple_CVec_u8Zu64Z_get_a(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR owner);
1822 export function C2Tuple_CVec_u8Zu64Z_get_a(owner: bigint): number {
1823 if(!isWasmInitialized) {
1824 throw new Error("initializeWasm() must be awaited first!");
1826 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_get_a(owner);
1827 return nativeResponseValue;
1829 // uint64_t C2Tuple_CVec_u8Zu64Z_get_b(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR owner);
1831 export function C2Tuple_CVec_u8Zu64Z_get_b(owner: bigint): bigint {
1832 if(!isWasmInitialized) {
1833 throw new Error("initializeWasm() must be awaited first!");
1835 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_get_b(owner);
1836 return nativeResponseValue;
1838 // struct LDKC2Tuple_CVec_u8Zu64Z CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR owner);
1840 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(owner: bigint): bigint {
1841 if(!isWasmInitialized) {
1842 throw new Error("initializeWasm() must be awaited first!");
1844 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(owner);
1845 return nativeResponseValue;
1847 // void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR owner);
1849 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(owner: bigint): void {
1850 if(!isWasmInitialized) {
1851 throw new Error("initializeWasm() must be awaited first!");
1853 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(owner);
1854 // debug statements here
1856 // struct LDKChannelDerivationParameters CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1858 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1859 if(!isWasmInitialized) {
1860 throw new Error("initializeWasm() must be awaited first!");
1862 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner);
1863 return nativeResponseValue;
1865 // struct LDKDecodeError CResult_ChannelDerivationParametersDecodeErrorZ_get_err(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1867 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1868 if(!isWasmInitialized) {
1869 throw new Error("initializeWasm() must be awaited first!");
1871 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner);
1872 return nativeResponseValue;
1874 // struct LDKHTLCDescriptor CResult_HTLCDescriptorDecodeErrorZ_get_ok(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1876 export function CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1877 if(!isWasmInitialized) {
1878 throw new Error("initializeWasm() must be awaited first!");
1880 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner);
1881 return nativeResponseValue;
1883 // struct LDKDecodeError CResult_HTLCDescriptorDecodeErrorZ_get_err(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1885 export function CResult_HTLCDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1886 if(!isWasmInitialized) {
1887 throw new Error("initializeWasm() must be awaited first!");
1889 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_err(owner);
1890 return nativeResponseValue;
1892 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1894 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
1895 if(!isWasmInitialized) {
1896 throw new Error("initializeWasm() must be awaited first!");
1898 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1899 // debug statements here
1901 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1903 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
1904 if(!isWasmInitialized) {
1905 throw new Error("initializeWasm() must be awaited first!");
1907 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1908 // debug statements here
1910 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1912 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
1913 if(!isWasmInitialized) {
1914 throw new Error("initializeWasm() must be awaited first!");
1916 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
1917 return nativeResponseValue;
1919 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1921 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
1922 if(!isWasmInitialized) {
1923 throw new Error("initializeWasm() must be awaited first!");
1925 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
1926 // debug statements here
1929 export class LDKCOption_BigEndianScalarZ {
1930 protected constructor() {}
1933 export function LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr: bigint): number {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr);
1938 return nativeResponseValue;
1941 export function LDKCOption_BigEndianScalarZ_Some_get_some(ptr: bigint): bigint {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_Some_get_some(ptr);
1946 return nativeResponseValue;
1948 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1950 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
1951 if(!isWasmInitialized) {
1952 throw new Error("initializeWasm() must be awaited first!");
1954 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
1955 return nativeResponseValue;
1957 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1959 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
1960 if(!isWasmInitialized) {
1961 throw new Error("initializeWasm() must be awaited first!");
1963 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
1964 // debug statements here
1966 // struct LDKECDSASignature CResult_ECDSASignatureNoneZ_get_ok(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1968 export function CResult_ECDSASignatureNoneZ_get_ok(owner: bigint): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_ok(owner);
1973 return nativeResponseValue;
1975 // void CResult_ECDSASignatureNoneZ_get_err(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1977 export function CResult_ECDSASignatureNoneZ_get_err(owner: bigint): void {
1978 if(!isWasmInitialized) {
1979 throw new Error("initializeWasm() must be awaited first!");
1981 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_err(owner);
1982 // debug statements here
1984 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
1986 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
1987 if(!isWasmInitialized) {
1988 throw new Error("initializeWasm() must be awaited first!");
1990 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
1991 return nativeResponseValue;
1993 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
1995 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
1996 if(!isWasmInitialized) {
1997 throw new Error("initializeWasm() must be awaited first!");
1999 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2000 // debug statements here
2002 // struct LDKECDSASignature C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
2004 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner: bigint): number {
2005 if(!isWasmInitialized) {
2006 throw new Error("initializeWasm() must be awaited first!");
2008 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner);
2009 return nativeResponseValue;
2011 // struct LDKCVec_ECDSASignatureZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
2013 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner: bigint): number {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner);
2018 return nativeResponseValue;
2020 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
2022 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner: bigint): bigint {
2023 if(!isWasmInitialized) {
2024 throw new Error("initializeWasm() must be awaited first!");
2026 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner);
2027 return nativeResponseValue;
2029 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
2031 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner: bigint): void {
2032 if(!isWasmInitialized) {
2033 throw new Error("initializeWasm() must be awaited first!");
2035 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner);
2036 // debug statements here
2039 export interface LDKChannelSigner {
2040 get_per_commitment_point (idx: bigint): number;
2041 release_commitment_secret (idx: bigint): number;
2042 validate_holder_commitment (holder_tx: bigint, outbound_htlc_preimages: number): bigint;
2043 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
2044 channel_keys_id (): number;
2045 provide_channel_parameters (channel_parameters: bigint): void;
2049 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
2050 if(!isWasmInitialized) {
2051 throw new Error("initializeWasm() must be awaited first!");
2053 var new_obj_idx = js_objs.length;
2054 for (var i = 0; i < js_objs.length; i++) {
2055 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2057 js_objs[i] = new WeakRef(impl);
2058 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
2060 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
2062 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
2063 if(!isWasmInitialized) {
2064 throw new Error("initializeWasm() must be awaited first!");
2066 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
2067 return nativeResponseValue;
2069 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
2071 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
2072 if(!isWasmInitialized) {
2073 throw new Error("initializeWasm() must be awaited first!");
2075 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
2076 return nativeResponseValue;
2078 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages
2080 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, outbound_htlc_preimages: number): bigint {
2081 if(!isWasmInitialized) {
2082 throw new Error("initializeWasm() must be awaited first!");
2084 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, outbound_htlc_preimages);
2085 return nativeResponseValue;
2087 // LDKCResult_NoneNoneZ ChannelSigner_validate_counterparty_revocation LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
2089 export function ChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
2090 if(!isWasmInitialized) {
2091 throw new Error("initializeWasm() must be awaited first!");
2093 const nativeResponseValue = wasm.TS_ChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
2094 return nativeResponseValue;
2096 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
2098 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
2099 if(!isWasmInitialized) {
2100 throw new Error("initializeWasm() must be awaited first!");
2102 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
2103 return nativeResponseValue;
2105 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
2107 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
2108 if(!isWasmInitialized) {
2109 throw new Error("initializeWasm() must be awaited first!");
2111 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
2112 // debug statements here
2114 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
2116 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
2117 if(!isWasmInitialized) {
2118 throw new Error("initializeWasm() must be awaited first!");
2120 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
2121 return nativeResponseValue;
2124 export interface LDKEcdsaChannelSigner {
2125 sign_counterparty_commitment (commitment_tx: bigint, inbound_htlc_preimages: number, outbound_htlc_preimages: number): bigint;
2126 sign_holder_commitment (commitment_tx: bigint): bigint;
2127 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
2128 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
2129 sign_holder_htlc_transaction (htlc_tx: number, input: number, htlc_descriptor: bigint): bigint;
2130 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
2131 sign_closing_transaction (closing_tx: bigint): bigint;
2132 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
2133 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
2137 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
2138 if(!isWasmInitialized) {
2139 throw new Error("initializeWasm() must be awaited first!");
2141 var new_obj_idx = js_objs.length;
2142 for (var i = 0; i < js_objs.length; i++) {
2143 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2145 js_objs[i] = new WeakRef(impl);
2146 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
2148 // LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages
2150 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, inbound_htlc_preimages: number, outbound_htlc_preimages: number): bigint {
2151 if(!isWasmInitialized) {
2152 throw new Error("initializeWasm() must be awaited first!");
2154 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
2155 return nativeResponseValue;
2157 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
2159 export function EcdsaChannelSigner_sign_holder_commitment(this_arg: bigint, commitment_tx: bigint): bigint {
2160 if(!isWasmInitialized) {
2161 throw new Error("initializeWasm() must be awaited first!");
2163 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment(this_arg, commitment_tx);
2164 return nativeResponseValue;
2166 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_justice_revoked_output LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]
2168 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
2169 if(!isWasmInitialized) {
2170 throw new Error("initializeWasm() must be awaited first!");
2172 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
2173 return nativeResponseValue;
2175 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_justice_revoked_htlc LDKEcdsaChannelSigner *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
2177 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
2178 if(!isWasmInitialized) {
2179 throw new Error("initializeWasm() must be awaited first!");
2181 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
2182 return nativeResponseValue;
2184 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_htlc_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor
2186 export function EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, htlc_descriptor: bigint): bigint {
2187 if(!isWasmInitialized) {
2188 throw new Error("initializeWasm() must be awaited first!");
2190 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg, htlc_tx, input, htlc_descriptor);
2191 return nativeResponseValue;
2193 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_counterparty_htlc_transaction LDKEcdsaChannelSigner *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
2195 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
2196 if(!isWasmInitialized) {
2197 throw new Error("initializeWasm() must be awaited first!");
2199 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2200 return nativeResponseValue;
2202 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2204 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
2205 if(!isWasmInitialized) {
2206 throw new Error("initializeWasm() must be awaited first!");
2208 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
2209 return nativeResponseValue;
2211 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
2213 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
2214 if(!isWasmInitialized) {
2215 throw new Error("initializeWasm() must be awaited first!");
2217 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
2218 return nativeResponseValue;
2220 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2222 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
2223 if(!isWasmInitialized) {
2224 throw new Error("initializeWasm() must be awaited first!");
2226 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
2227 return nativeResponseValue;
2230 export interface LDKWriteableEcdsaChannelSigner {
2235 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
2236 if(!isWasmInitialized) {
2237 throw new Error("initializeWasm() must be awaited first!");
2239 var new_obj_idx = js_objs.length;
2240 for (var i = 0; i < js_objs.length; i++) {
2241 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2243 js_objs[i] = new WeakRef(impl);
2244 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
2246 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
2248 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
2249 if(!isWasmInitialized) {
2250 throw new Error("initializeWasm() must be awaited first!");
2252 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
2253 return nativeResponseValue;
2255 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2257 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2258 if(!isWasmInitialized) {
2259 throw new Error("initializeWasm() must be awaited first!");
2261 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
2262 return nativeResponseValue;
2264 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2266 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
2267 if(!isWasmInitialized) {
2268 throw new Error("initializeWasm() must be awaited first!");
2270 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
2271 return nativeResponseValue;
2273 // struct LDKCVec_u8Z CResult_CVec_u8ZNoneZ_get_ok(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2275 export function CResult_CVec_u8ZNoneZ_get_ok(owner: bigint): number {
2276 if(!isWasmInitialized) {
2277 throw new Error("initializeWasm() must be awaited first!");
2279 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_ok(owner);
2280 return nativeResponseValue;
2282 // void CResult_CVec_u8ZNoneZ_get_err(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2284 export function CResult_CVec_u8ZNoneZ_get_err(owner: bigint): void {
2285 if(!isWasmInitialized) {
2286 throw new Error("initializeWasm() must be awaited first!");
2288 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_err(owner);
2289 // debug statements here
2291 // struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2293 export function CResult_ShutdownScriptNoneZ_get_ok(owner: bigint): bigint {
2294 if(!isWasmInitialized) {
2295 throw new Error("initializeWasm() must be awaited first!");
2297 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_ok(owner);
2298 return nativeResponseValue;
2300 // void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2302 export function CResult_ShutdownScriptNoneZ_get_err(owner: bigint): void {
2303 if(!isWasmInitialized) {
2304 throw new Error("initializeWasm() must be awaited first!");
2306 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_err(owner);
2307 // debug statements here
2310 export class LDKCOption_u16Z {
2311 protected constructor() {}
2314 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
2315 if(!isWasmInitialized) {
2316 throw new Error("initializeWasm() must be awaited first!");
2318 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2319 return nativeResponseValue;
2322 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
2323 if(!isWasmInitialized) {
2324 throw new Error("initializeWasm() must be awaited first!");
2326 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2327 return nativeResponseValue;
2330 export class LDKCOption_boolZ {
2331 protected constructor() {}
2334 export function LDKCOption_boolZ_ty_from_ptr(ptr: bigint): number {
2335 if(!isWasmInitialized) {
2336 throw new Error("initializeWasm() must be awaited first!");
2338 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_ty_from_ptr(ptr);
2339 return nativeResponseValue;
2342 export function LDKCOption_boolZ_Some_get_some(ptr: bigint): boolean {
2343 if(!isWasmInitialized) {
2344 throw new Error("initializeWasm() must be awaited first!");
2346 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_Some_get_some(ptr);
2347 return nativeResponseValue;
2349 // struct LDKWitness CResult_WitnessNoneZ_get_ok(LDKCResult_WitnessNoneZ *NONNULL_PTR owner);
2351 export function CResult_WitnessNoneZ_get_ok(owner: bigint): number {
2352 if(!isWasmInitialized) {
2353 throw new Error("initializeWasm() must be awaited first!");
2355 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_get_ok(owner);
2356 return nativeResponseValue;
2358 // void CResult_WitnessNoneZ_get_err(LDKCResult_WitnessNoneZ *NONNULL_PTR owner);
2360 export function CResult_WitnessNoneZ_get_err(owner: bigint): void {
2361 if(!isWasmInitialized) {
2362 throw new Error("initializeWasm() must be awaited first!");
2364 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_get_err(owner);
2365 // debug statements here
2367 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2369 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2370 if(!isWasmInitialized) {
2371 throw new Error("initializeWasm() must be awaited first!");
2373 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2374 return nativeResponseValue;
2376 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2378 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
2379 if(!isWasmInitialized) {
2380 throw new Error("initializeWasm() must be awaited first!");
2382 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2383 return nativeResponseValue;
2385 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2387 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
2388 if(!isWasmInitialized) {
2389 throw new Error("initializeWasm() must be awaited first!");
2391 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2392 return nativeResponseValue;
2394 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2396 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2401 return nativeResponseValue;
2403 // struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2405 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
2406 if(!isWasmInitialized) {
2407 throw new Error("initializeWasm() must be awaited first!");
2409 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
2410 return nativeResponseValue;
2412 // struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2414 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
2415 if(!isWasmInitialized) {
2416 throw new Error("initializeWasm() must be awaited first!");
2418 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
2419 return nativeResponseValue;
2421 // struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR owner);
2423 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(owner: bigint): number {
2424 if(!isWasmInitialized) {
2425 throw new Error("initializeWasm() must be awaited first!");
2427 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(owner);
2428 return nativeResponseValue;
2430 // void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR owner);
2432 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(owner: bigint): void {
2433 if(!isWasmInitialized) {
2434 throw new Error("initializeWasm() must be awaited first!");
2436 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(owner);
2437 // debug statements here
2439 // struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
2441 export function CResult_OnionMessagePathNoneZ_get_ok(owner: bigint): bigint {
2442 if(!isWasmInitialized) {
2443 throw new Error("initializeWasm() must be awaited first!");
2445 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_ok(owner);
2446 return nativeResponseValue;
2448 // void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
2450 export function CResult_OnionMessagePathNoneZ_get_err(owner: bigint): void {
2451 if(!isWasmInitialized) {
2452 throw new Error("initializeWasm() must be awaited first!");
2454 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_err(owner);
2455 // debug statements here
2457 // struct LDKCVec_BlindedPathZ CResult_CVec_BlindedPathZNoneZ_get_ok(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR owner);
2459 export function CResult_CVec_BlindedPathZNoneZ_get_ok(owner: bigint): number {
2460 if(!isWasmInitialized) {
2461 throw new Error("initializeWasm() must be awaited first!");
2463 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_get_ok(owner);
2464 return nativeResponseValue;
2466 // void CResult_CVec_BlindedPathZNoneZ_get_err(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR owner);
2468 export function CResult_CVec_BlindedPathZNoneZ_get_err(owner: bigint): void {
2469 if(!isWasmInitialized) {
2470 throw new Error("initializeWasm() must be awaited first!");
2472 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_get_err(owner);
2473 // debug statements here
2475 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2477 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
2478 if(!isWasmInitialized) {
2479 throw new Error("initializeWasm() must be awaited first!");
2481 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
2482 return nativeResponseValue;
2484 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2486 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
2487 if(!isWasmInitialized) {
2488 throw new Error("initializeWasm() must be awaited first!");
2490 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
2491 return nativeResponseValue;
2493 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2495 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2496 if(!isWasmInitialized) {
2497 throw new Error("initializeWasm() must be awaited first!");
2499 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
2500 return nativeResponseValue;
2502 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2504 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
2505 if(!isWasmInitialized) {
2506 throw new Error("initializeWasm() must be awaited first!");
2508 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
2509 return nativeResponseValue;
2511 // struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2513 export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
2514 if(!isWasmInitialized) {
2515 throw new Error("initializeWasm() must be awaited first!");
2517 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
2518 return nativeResponseValue;
2520 // struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2522 export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
2523 if(!isWasmInitialized) {
2524 throw new Error("initializeWasm() must be awaited first!");
2526 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
2527 return nativeResponseValue;
2529 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2531 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
2532 if(!isWasmInitialized) {
2533 throw new Error("initializeWasm() must be awaited first!");
2535 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
2536 return nativeResponseValue;
2538 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2540 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
2541 if(!isWasmInitialized) {
2542 throw new Error("initializeWasm() must be awaited first!");
2544 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
2545 return nativeResponseValue;
2547 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2549 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2550 if(!isWasmInitialized) {
2551 throw new Error("initializeWasm() must be awaited first!");
2553 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
2554 return nativeResponseValue;
2556 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2558 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2559 if(!isWasmInitialized) {
2560 throw new Error("initializeWasm() must be awaited first!");
2562 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
2563 return nativeResponseValue;
2565 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2567 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2568 if(!isWasmInitialized) {
2569 throw new Error("initializeWasm() must be awaited first!");
2571 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
2572 return nativeResponseValue;
2574 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2576 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2577 if(!isWasmInitialized) {
2578 throw new Error("initializeWasm() must be awaited first!");
2580 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
2581 return nativeResponseValue;
2583 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2585 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
2586 if(!isWasmInitialized) {
2587 throw new Error("initializeWasm() must be awaited first!");
2589 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2590 return nativeResponseValue;
2592 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2594 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
2595 if(!isWasmInitialized) {
2596 throw new Error("initializeWasm() must be awaited first!");
2598 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2599 return nativeResponseValue;
2601 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2603 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2604 if(!isWasmInitialized) {
2605 throw new Error("initializeWasm() must be awaited first!");
2607 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2608 return nativeResponseValue;
2610 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2612 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
2613 if(!isWasmInitialized) {
2614 throw new Error("initializeWasm() must be awaited first!");
2616 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2617 return nativeResponseValue;
2619 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2621 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2622 if(!isWasmInitialized) {
2623 throw new Error("initializeWasm() must be awaited first!");
2625 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2626 return nativeResponseValue;
2628 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2630 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2631 if(!isWasmInitialized) {
2632 throw new Error("initializeWasm() must be awaited first!");
2634 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2635 return nativeResponseValue;
2637 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2639 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2640 if(!isWasmInitialized) {
2641 throw new Error("initializeWasm() must be awaited first!");
2643 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2644 return nativeResponseValue;
2646 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2648 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2649 if(!isWasmInitialized) {
2650 throw new Error("initializeWasm() must be awaited first!");
2652 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2653 return nativeResponseValue;
2656 export class LDKCOption_C2Tuple_u64u64ZZ {
2657 protected constructor() {}
2660 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2661 if(!isWasmInitialized) {
2662 throw new Error("initializeWasm() must be awaited first!");
2664 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2665 return nativeResponseValue;
2668 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2669 if(!isWasmInitialized) {
2670 throw new Error("initializeWasm() must be awaited first!");
2672 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2673 return nativeResponseValue;
2675 // struct LDKThirtyTwoU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
2677 export function C2Tuple_Z_get_a(owner: bigint): number {
2678 if(!isWasmInitialized) {
2679 throw new Error("initializeWasm() must be awaited first!");
2681 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
2682 return nativeResponseValue;
2684 // struct LDKThirtyTwoU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
2686 export function C2Tuple_Z_get_b(owner: bigint): number {
2687 if(!isWasmInitialized) {
2688 throw new Error("initializeWasm() must be awaited first!");
2690 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
2691 return nativeResponseValue;
2693 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_a(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2695 export function C2Tuple__u1632_u1632Z_get_a(owner: bigint): number {
2696 if(!isWasmInitialized) {
2697 throw new Error("initializeWasm() must be awaited first!");
2699 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_a(owner);
2700 return nativeResponseValue;
2702 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_b(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2704 export function C2Tuple__u1632_u1632Z_get_b(owner: bigint): number {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_b(owner);
2709 return nativeResponseValue;
2712 export class LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
2713 protected constructor() {}
2716 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr: bigint): number {
2717 if(!isWasmInitialized) {
2718 throw new Error("initializeWasm() must be awaited first!");
2720 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr);
2721 return nativeResponseValue;
2724 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr: bigint): bigint {
2725 if(!isWasmInitialized) {
2726 throw new Error("initializeWasm() must be awaited first!");
2728 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr);
2729 return nativeResponseValue;
2732 export class LDKCOption_f64Z {
2733 protected constructor() {}
2736 export function LDKCOption_f64Z_ty_from_ptr(ptr: bigint): number {
2737 if(!isWasmInitialized) {
2738 throw new Error("initializeWasm() must be awaited first!");
2740 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_ty_from_ptr(ptr);
2741 return nativeResponseValue;
2744 export function LDKCOption_f64Z_Some_get_some(ptr: bigint): number {
2745 if(!isWasmInitialized) {
2746 throw new Error("initializeWasm() must be awaited first!");
2748 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_Some_get_some(ptr);
2749 return nativeResponseValue;
2752 export interface LDKLogger {
2753 log (record: bigint): void;
2757 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2758 if(!isWasmInitialized) {
2759 throw new Error("initializeWasm() must be awaited first!");
2761 var new_obj_idx = js_objs.length;
2762 for (var i = 0; i < js_objs.length; i++) {
2763 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2765 js_objs[i] = new WeakRef(impl);
2766 return [wasm.TS_LDKLogger_new(i), i];
2768 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2770 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2771 if(!isWasmInitialized) {
2772 throw new Error("initializeWasm() must be awaited first!");
2774 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2775 return nativeResponseValue;
2777 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2779 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2780 if(!isWasmInitialized) {
2781 throw new Error("initializeWasm() must be awaited first!");
2783 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2784 return nativeResponseValue;
2786 // struct LDKBestBlock CResult_BestBlockDecodeErrorZ_get_ok(LDKCResult_BestBlockDecodeErrorZ *NONNULL_PTR owner);
2788 export function CResult_BestBlockDecodeErrorZ_get_ok(owner: bigint): bigint {
2789 if(!isWasmInitialized) {
2790 throw new Error("initializeWasm() must be awaited first!");
2792 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_get_ok(owner);
2793 return nativeResponseValue;
2795 // struct LDKDecodeError CResult_BestBlockDecodeErrorZ_get_err(LDKCResult_BestBlockDecodeErrorZ *NONNULL_PTR owner);
2797 export function CResult_BestBlockDecodeErrorZ_get_err(owner: bigint): bigint {
2798 if(!isWasmInitialized) {
2799 throw new Error("initializeWasm() must be awaited first!");
2801 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_get_err(owner);
2802 return nativeResponseValue;
2804 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2806 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2807 if(!isWasmInitialized) {
2808 throw new Error("initializeWasm() must be awaited first!");
2810 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2811 return nativeResponseValue;
2813 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2815 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2816 if(!isWasmInitialized) {
2817 throw new Error("initializeWasm() must be awaited first!");
2819 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2820 return nativeResponseValue;
2822 // struct LDKThirtyTwoBytes C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2824 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(owner: bigint): number {
2825 if(!isWasmInitialized) {
2826 throw new Error("initializeWasm() must be awaited first!");
2828 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(owner);
2829 return nativeResponseValue;
2831 // uint32_t C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2833 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(owner: bigint): number {
2834 if(!isWasmInitialized) {
2835 throw new Error("initializeWasm() must be awaited first!");
2837 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(owner);
2838 return nativeResponseValue;
2840 // struct LDKCOption_ThirtyTwoBytesZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2842 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(owner: bigint): bigint {
2843 if(!isWasmInitialized) {
2844 throw new Error("initializeWasm() must be awaited first!");
2846 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(owner);
2847 return nativeResponseValue;
2849 // enum LDKChannelMonitorUpdateStatus CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2851 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner: bigint): ChannelMonitorUpdateStatus {
2852 if(!isWasmInitialized) {
2853 throw new Error("initializeWasm() must be awaited first!");
2855 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner);
2856 return nativeResponseValue;
2858 // void CResult_ChannelMonitorUpdateStatusNoneZ_get_err(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2860 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner: bigint): void {
2861 if(!isWasmInitialized) {
2862 throw new Error("initializeWasm() must be awaited first!");
2864 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner);
2865 // debug statements here
2868 export class LDKClosureReason {
2869 protected constructor() {}
2872 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
2873 if(!isWasmInitialized) {
2874 throw new Error("initializeWasm() must be awaited first!");
2876 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
2877 return nativeResponseValue;
2880 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
2881 if(!isWasmInitialized) {
2882 throw new Error("initializeWasm() must be awaited first!");
2884 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
2885 return nativeResponseValue;
2888 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
2889 if(!isWasmInitialized) {
2890 throw new Error("initializeWasm() must be awaited first!");
2892 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
2893 return nativeResponseValue;
2896 export class LDKMonitorEvent {
2897 protected constructor() {}
2900 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2901 if(!isWasmInitialized) {
2902 throw new Error("initializeWasm() must be awaited first!");
2904 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2905 return nativeResponseValue;
2908 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2913 return nativeResponseValue;
2916 export function LDKMonitorEvent_HolderForceClosedWithInfo_get_reason(ptr: bigint): bigint {
2917 if(!isWasmInitialized) {
2918 throw new Error("initializeWasm() must be awaited first!");
2920 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosedWithInfo_get_reason(ptr);
2921 return nativeResponseValue;
2924 export function LDKMonitorEvent_HolderForceClosedWithInfo_get_outpoint(ptr: bigint): bigint {
2925 if(!isWasmInitialized) {
2926 throw new Error("initializeWasm() must be awaited first!");
2928 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosedWithInfo_get_outpoint(ptr);
2929 return nativeResponseValue;
2932 export function LDKMonitorEvent_HolderForceClosedWithInfo_get_channel_id(ptr: bigint): bigint {
2933 if(!isWasmInitialized) {
2934 throw new Error("initializeWasm() must be awaited first!");
2936 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosedWithInfo_get_channel_id(ptr);
2937 return nativeResponseValue;
2940 export function LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr: bigint): bigint {
2941 if(!isWasmInitialized) {
2942 throw new Error("initializeWasm() must be awaited first!");
2944 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr);
2945 return nativeResponseValue;
2948 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2949 if(!isWasmInitialized) {
2950 throw new Error("initializeWasm() must be awaited first!");
2952 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2953 return nativeResponseValue;
2956 export function LDKMonitorEvent_Completed_get_channel_id(ptr: bigint): bigint {
2957 if(!isWasmInitialized) {
2958 throw new Error("initializeWasm() must be awaited first!");
2960 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_channel_id(ptr);
2961 return nativeResponseValue;
2964 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2965 if(!isWasmInitialized) {
2966 throw new Error("initializeWasm() must be awaited first!");
2968 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2969 return nativeResponseValue;
2971 // struct LDKOutPoint C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_a(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2973 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2974 if(!isWasmInitialized) {
2975 throw new Error("initializeWasm() must be awaited first!");
2977 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_a(owner);
2978 return nativeResponseValue;
2980 // struct LDKChannelId C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_b(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2982 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): bigint {
2983 if(!isWasmInitialized) {
2984 throw new Error("initializeWasm() must be awaited first!");
2986 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_b(owner);
2987 return nativeResponseValue;
2989 // struct LDKCVec_MonitorEventZ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_c(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2991 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_c(owner);
2996 return nativeResponseValue;
2998 // struct LDKPublicKey C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_d(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
3000 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_d(owner: bigint): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_get_d(owner);
3005 return nativeResponseValue;
3007 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
3009 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3010 if(!isWasmInitialized) {
3011 throw new Error("initializeWasm() must be awaited first!");
3013 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
3014 return nativeResponseValue;
3016 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
3018 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3019 if(!isWasmInitialized) {
3020 throw new Error("initializeWasm() must be awaited first!");
3022 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
3023 return nativeResponseValue;
3025 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3027 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
3032 return nativeResponseValue;
3034 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3036 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
3041 return nativeResponseValue;
3043 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3045 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
3050 return nativeResponseValue;
3052 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3054 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3055 if(!isWasmInitialized) {
3056 throw new Error("initializeWasm() must be awaited first!");
3058 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
3059 return nativeResponseValue;
3061 // struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3063 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner);
3068 return nativeResponseValue;
3070 // struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3072 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner);
3077 return nativeResponseValue;
3079 // struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3081 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner);
3086 return nativeResponseValue;
3088 // struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3090 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner);
3095 return nativeResponseValue;
3097 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
3099 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
3104 return nativeResponseValue;
3106 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
3108 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
3113 return nativeResponseValue;
3115 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3117 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
3122 return nativeResponseValue;
3124 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3126 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
3131 return nativeResponseValue;
3133 // struct LDKOfferId CResult_OfferIdDecodeErrorZ_get_ok(LDKCResult_OfferIdDecodeErrorZ *NONNULL_PTR owner);
3135 export function CResult_OfferIdDecodeErrorZ_get_ok(owner: bigint): bigint {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_get_ok(owner);
3140 return nativeResponseValue;
3142 // struct LDKDecodeError CResult_OfferIdDecodeErrorZ_get_err(LDKCResult_OfferIdDecodeErrorZ *NONNULL_PTR owner);
3144 export function CResult_OfferIdDecodeErrorZ_get_err(owner: bigint): bigint {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_get_err(owner);
3149 return nativeResponseValue;
3151 // void CResult_NoneBolt12SemanticErrorZ_get_ok(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
3153 export function CResult_NoneBolt12SemanticErrorZ_get_ok(owner: bigint): void {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_ok(owner);
3158 // debug statements here
3160 // enum LDKBolt12SemanticError CResult_NoneBolt12SemanticErrorZ_get_err(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
3162 export function CResult_NoneBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_err(owner);
3167 return nativeResponseValue;
3169 // struct LDKOffer CResult_OfferBolt12SemanticErrorZ_get_ok(LDKCResult_OfferBolt12SemanticErrorZ *NONNULL_PTR owner);
3171 export function CResult_OfferBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_get_ok(owner);
3176 return nativeResponseValue;
3178 // enum LDKBolt12SemanticError CResult_OfferBolt12SemanticErrorZ_get_err(LDKCResult_OfferBolt12SemanticErrorZ *NONNULL_PTR owner);
3180 export function CResult_OfferBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_get_err(owner);
3185 return nativeResponseValue;
3187 // struct LDKInvoiceRequestWithDerivedPayerIdBuilder CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
3189 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_ok(owner);
3194 return nativeResponseValue;
3196 // enum LDKBolt12SemanticError CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_err(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
3198 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_get_err(owner);
3203 return nativeResponseValue;
3205 // struct LDKInvoiceRequestWithExplicitPayerIdBuilder CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
3207 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_ok(owner);
3212 return nativeResponseValue;
3214 // enum LDKBolt12SemanticError CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_err(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
3216 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_get_err(owner);
3221 return nativeResponseValue;
3223 // struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
3225 export function CResult_OfferBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_ok(owner);
3230 return nativeResponseValue;
3232 // struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
3234 export function CResult_OfferBolt12ParseErrorZ_get_err(owner: bigint): bigint {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_err(owner);
3239 return nativeResponseValue;
3241 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3243 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
3248 return nativeResponseValue;
3250 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
3252 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
3257 return nativeResponseValue;
3259 // struct LDKPublicKey CResult_PublicKeySecp256k1ErrorZ_get_ok(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
3261 export function CResult_PublicKeySecp256k1ErrorZ_get_ok(owner: bigint): number {
3262 if(!isWasmInitialized) {
3263 throw new Error("initializeWasm() must be awaited first!");
3265 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_ok(owner);
3266 return nativeResponseValue;
3268 // enum LDKSecp256k1Error CResult_PublicKeySecp256k1ErrorZ_get_err(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
3270 export function CResult_PublicKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
3271 if(!isWasmInitialized) {
3272 throw new Error("initializeWasm() must be awaited first!");
3274 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_err(owner);
3275 return nativeResponseValue;
3278 export class LDKNetworkUpdate {
3279 protected constructor() {}
3282 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
3283 if(!isWasmInitialized) {
3284 throw new Error("initializeWasm() must be awaited first!");
3286 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
3287 return nativeResponseValue;
3290 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
3291 if(!isWasmInitialized) {
3292 throw new Error("initializeWasm() must be awaited first!");
3294 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
3295 return nativeResponseValue;
3298 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
3299 if(!isWasmInitialized) {
3300 throw new Error("initializeWasm() must be awaited first!");
3302 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
3303 return nativeResponseValue;
3306 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
3307 if(!isWasmInitialized) {
3308 throw new Error("initializeWasm() must be awaited first!");
3310 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
3311 return nativeResponseValue;
3314 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
3315 if(!isWasmInitialized) {
3316 throw new Error("initializeWasm() must be awaited first!");
3318 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
3319 return nativeResponseValue;
3322 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
3323 if(!isWasmInitialized) {
3324 throw new Error("initializeWasm() must be awaited first!");
3326 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
3327 return nativeResponseValue;
3330 export class LDKCOption_NetworkUpdateZ {
3331 protected constructor() {}
3334 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
3335 if(!isWasmInitialized) {
3336 throw new Error("initializeWasm() must be awaited first!");
3338 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
3339 return nativeResponseValue;
3342 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
3343 if(!isWasmInitialized) {
3344 throw new Error("initializeWasm() must be awaited first!");
3346 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
3347 return nativeResponseValue;
3349 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3351 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
3356 return nativeResponseValue;
3358 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
3360 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
3361 if(!isWasmInitialized) {
3362 throw new Error("initializeWasm() must be awaited first!");
3364 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
3365 return nativeResponseValue;
3367 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
3369 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
3370 if(!isWasmInitialized) {
3371 throw new Error("initializeWasm() must be awaited first!");
3373 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
3374 return nativeResponseValue;
3376 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
3378 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
3379 if(!isWasmInitialized) {
3380 throw new Error("initializeWasm() must be awaited first!");
3382 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
3383 return nativeResponseValue;
3386 export class LDKUtxoResult {
3387 protected constructor() {}
3390 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
3391 if(!isWasmInitialized) {
3392 throw new Error("initializeWasm() must be awaited first!");
3394 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
3395 return nativeResponseValue;
3398 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
3399 if(!isWasmInitialized) {
3400 throw new Error("initializeWasm() must be awaited first!");
3402 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
3403 return nativeResponseValue;
3406 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
3407 if(!isWasmInitialized) {
3408 throw new Error("initializeWasm() must be awaited first!");
3410 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
3411 return nativeResponseValue;
3414 export interface LDKUtxoLookup {
3415 get_utxo (chain_hash: number, short_channel_id: bigint): bigint;
3419 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
3420 if(!isWasmInitialized) {
3421 throw new Error("initializeWasm() must be awaited first!");
3423 var new_obj_idx = js_objs.length;
3424 for (var i = 0; i < js_objs.length; i++) {
3425 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3427 js_objs[i] = new WeakRef(impl);
3428 return [wasm.TS_LDKUtxoLookup_new(i), i];
3430 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*chain_hash)[32], uint64_t short_channel_id
3432 export function UtxoLookup_get_utxo(this_arg: bigint, chain_hash: number, short_channel_id: bigint): bigint {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, chain_hash, short_channel_id);
3437 return nativeResponseValue;
3440 export class LDKCOption_UtxoLookupZ {
3441 protected constructor() {}
3444 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
3445 if(!isWasmInitialized) {
3446 throw new Error("initializeWasm() must be awaited first!");
3448 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
3449 return nativeResponseValue;
3452 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
3453 if(!isWasmInitialized) {
3454 throw new Error("initializeWasm() must be awaited first!");
3456 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
3457 return nativeResponseValue;
3459 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3461 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
3462 if(!isWasmInitialized) {
3463 throw new Error("initializeWasm() must be awaited first!");
3465 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
3466 // debug statements here
3468 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3470 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
3471 if(!isWasmInitialized) {
3472 throw new Error("initializeWasm() must be awaited first!");
3474 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
3475 return nativeResponseValue;
3477 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3479 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
3480 if(!isWasmInitialized) {
3481 throw new Error("initializeWasm() must be awaited first!");
3483 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
3484 return nativeResponseValue;
3486 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3488 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
3489 if(!isWasmInitialized) {
3490 throw new Error("initializeWasm() must be awaited first!");
3492 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
3493 return nativeResponseValue;
3495 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3497 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
3502 return nativeResponseValue;
3504 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3506 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
3507 if(!isWasmInitialized) {
3508 throw new Error("initializeWasm() must be awaited first!");
3510 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
3511 return nativeResponseValue;
3513 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3515 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
3516 if(!isWasmInitialized) {
3517 throw new Error("initializeWasm() must be awaited first!");
3519 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
3520 return nativeResponseValue;
3523 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
3524 protected constructor() {}
3527 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
3528 if(!isWasmInitialized) {
3529 throw new Error("initializeWasm() must be awaited first!");
3531 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
3532 return nativeResponseValue;
3535 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3536 if(!isWasmInitialized) {
3537 throw new Error("initializeWasm() must be awaited first!");
3539 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3540 return nativeResponseValue;
3543 export class LDKErrorAction {
3544 protected constructor() {}
3547 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
3548 if(!isWasmInitialized) {
3549 throw new Error("initializeWasm() must be awaited first!");
3551 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
3552 return nativeResponseValue;
3555 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
3556 if(!isWasmInitialized) {
3557 throw new Error("initializeWasm() must be awaited first!");
3559 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
3560 return nativeResponseValue;
3563 export function LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr: bigint): bigint {
3564 if(!isWasmInitialized) {
3565 throw new Error("initializeWasm() must be awaited first!");
3567 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr);
3568 return nativeResponseValue;
3571 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
3572 if(!isWasmInitialized) {
3573 throw new Error("initializeWasm() must be awaited first!");
3575 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
3576 return nativeResponseValue;
3579 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
3580 if(!isWasmInitialized) {
3581 throw new Error("initializeWasm() must be awaited first!");
3583 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
3584 return nativeResponseValue;
3587 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
3588 if(!isWasmInitialized) {
3589 throw new Error("initializeWasm() must be awaited first!");
3591 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
3592 return nativeResponseValue;
3595 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
3596 if(!isWasmInitialized) {
3597 throw new Error("initializeWasm() must be awaited first!");
3599 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
3600 return nativeResponseValue;
3603 export class LDKMessageSendEvent {
3604 protected constructor() {}
3607 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
3608 if(!isWasmInitialized) {
3609 throw new Error("initializeWasm() must be awaited first!");
3611 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
3612 return nativeResponseValue;
3615 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
3616 if(!isWasmInitialized) {
3617 throw new Error("initializeWasm() must be awaited first!");
3619 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
3620 return nativeResponseValue;
3623 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
3624 if(!isWasmInitialized) {
3625 throw new Error("initializeWasm() must be awaited first!");
3627 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
3628 return nativeResponseValue;
3631 export function LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr: bigint): number {
3632 if(!isWasmInitialized) {
3633 throw new Error("initializeWasm() must be awaited first!");
3635 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
3636 return nativeResponseValue;
3639 export function LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr: bigint): bigint {
3640 if(!isWasmInitialized) {
3641 throw new Error("initializeWasm() must be awaited first!");
3643 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
3644 return nativeResponseValue;
3647 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
3648 if(!isWasmInitialized) {
3649 throw new Error("initializeWasm() must be awaited first!");
3651 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
3652 return nativeResponseValue;
3655 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
3656 if(!isWasmInitialized) {
3657 throw new Error("initializeWasm() must be awaited first!");
3659 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
3660 return nativeResponseValue;
3663 export function LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr: bigint): number {
3664 if(!isWasmInitialized) {
3665 throw new Error("initializeWasm() must be awaited first!");
3667 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
3668 return nativeResponseValue;
3671 export function LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr: bigint): bigint {
3672 if(!isWasmInitialized) {
3673 throw new Error("initializeWasm() must be awaited first!");
3675 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
3676 return nativeResponseValue;
3679 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
3680 if(!isWasmInitialized) {
3681 throw new Error("initializeWasm() must be awaited first!");
3683 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
3684 return nativeResponseValue;
3687 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
3688 if(!isWasmInitialized) {
3689 throw new Error("initializeWasm() must be awaited first!");
3691 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
3692 return nativeResponseValue;
3695 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
3696 if(!isWasmInitialized) {
3697 throw new Error("initializeWasm() must be awaited first!");
3699 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
3700 return nativeResponseValue;
3703 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
3704 if(!isWasmInitialized) {
3705 throw new Error("initializeWasm() must be awaited first!");
3707 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
3708 return nativeResponseValue;
3711 export function LDKMessageSendEvent_SendStfu_get_node_id(ptr: bigint): number {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendStfu_get_node_id(ptr);
3716 return nativeResponseValue;
3719 export function LDKMessageSendEvent_SendStfu_get_msg(ptr: bigint): bigint {
3720 if(!isWasmInitialized) {
3721 throw new Error("initializeWasm() must be awaited first!");
3723 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendStfu_get_msg(ptr);
3724 return nativeResponseValue;
3727 export function LDKMessageSendEvent_SendSplice_get_node_id(ptr: bigint): number {
3728 if(!isWasmInitialized) {
3729 throw new Error("initializeWasm() must be awaited first!");
3731 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSplice_get_node_id(ptr);
3732 return nativeResponseValue;
3735 export function LDKMessageSendEvent_SendSplice_get_msg(ptr: bigint): bigint {
3736 if(!isWasmInitialized) {
3737 throw new Error("initializeWasm() must be awaited first!");
3739 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSplice_get_msg(ptr);
3740 return nativeResponseValue;
3743 export function LDKMessageSendEvent_SendSpliceAck_get_node_id(ptr: bigint): number {
3744 if(!isWasmInitialized) {
3745 throw new Error("initializeWasm() must be awaited first!");
3747 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceAck_get_node_id(ptr);
3748 return nativeResponseValue;
3751 export function LDKMessageSendEvent_SendSpliceAck_get_msg(ptr: bigint): bigint {
3752 if(!isWasmInitialized) {
3753 throw new Error("initializeWasm() must be awaited first!");
3755 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceAck_get_msg(ptr);
3756 return nativeResponseValue;
3759 export function LDKMessageSendEvent_SendSpliceLocked_get_node_id(ptr: bigint): number {
3760 if(!isWasmInitialized) {
3761 throw new Error("initializeWasm() must be awaited first!");
3763 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceLocked_get_node_id(ptr);
3764 return nativeResponseValue;
3767 export function LDKMessageSendEvent_SendSpliceLocked_get_msg(ptr: bigint): bigint {
3768 if(!isWasmInitialized) {
3769 throw new Error("initializeWasm() must be awaited first!");
3771 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceLocked_get_msg(ptr);
3772 return nativeResponseValue;
3775 export function LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr: bigint): number {
3776 if(!isWasmInitialized) {
3777 throw new Error("initializeWasm() must be awaited first!");
3779 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
3780 return nativeResponseValue;
3783 export function LDKMessageSendEvent_SendTxAddInput_get_msg(ptr: bigint): bigint {
3784 if(!isWasmInitialized) {
3785 throw new Error("initializeWasm() must be awaited first!");
3787 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
3788 return nativeResponseValue;
3791 export function LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr: bigint): number {
3792 if(!isWasmInitialized) {
3793 throw new Error("initializeWasm() must be awaited first!");
3795 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
3796 return nativeResponseValue;
3799 export function LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr: bigint): bigint {
3800 if(!isWasmInitialized) {
3801 throw new Error("initializeWasm() must be awaited first!");
3803 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
3804 return nativeResponseValue;
3807 export function LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr: bigint): number {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
3812 return nativeResponseValue;
3815 export function LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr: bigint): bigint {
3816 if(!isWasmInitialized) {
3817 throw new Error("initializeWasm() must be awaited first!");
3819 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
3820 return nativeResponseValue;
3823 export function LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr: bigint): number {
3824 if(!isWasmInitialized) {
3825 throw new Error("initializeWasm() must be awaited first!");
3827 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
3828 return nativeResponseValue;
3831 export function LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr: bigint): bigint {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
3836 return nativeResponseValue;
3839 export function LDKMessageSendEvent_SendTxComplete_get_node_id(ptr: bigint): number {
3840 if(!isWasmInitialized) {
3841 throw new Error("initializeWasm() must be awaited first!");
3843 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
3844 return nativeResponseValue;
3847 export function LDKMessageSendEvent_SendTxComplete_get_msg(ptr: bigint): bigint {
3848 if(!isWasmInitialized) {
3849 throw new Error("initializeWasm() must be awaited first!");
3851 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
3852 return nativeResponseValue;
3855 export function LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr: bigint): number {
3856 if(!isWasmInitialized) {
3857 throw new Error("initializeWasm() must be awaited first!");
3859 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
3860 return nativeResponseValue;
3863 export function LDKMessageSendEvent_SendTxSignatures_get_msg(ptr: bigint): bigint {
3864 if(!isWasmInitialized) {
3865 throw new Error("initializeWasm() must be awaited first!");
3867 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
3868 return nativeResponseValue;
3871 export function LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr: bigint): number {
3872 if(!isWasmInitialized) {
3873 throw new Error("initializeWasm() must be awaited first!");
3875 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
3876 return nativeResponseValue;
3879 export function LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr: bigint): bigint {
3880 if(!isWasmInitialized) {
3881 throw new Error("initializeWasm() must be awaited first!");
3883 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
3884 return nativeResponseValue;
3887 export function LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr: bigint): number {
3888 if(!isWasmInitialized) {
3889 throw new Error("initializeWasm() must be awaited first!");
3891 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
3892 return nativeResponseValue;
3895 export function LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr: bigint): bigint {
3896 if(!isWasmInitialized) {
3897 throw new Error("initializeWasm() must be awaited first!");
3899 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
3900 return nativeResponseValue;
3903 export function LDKMessageSendEvent_SendTxAbort_get_node_id(ptr: bigint): number {
3904 if(!isWasmInitialized) {
3905 throw new Error("initializeWasm() must be awaited first!");
3907 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
3908 return nativeResponseValue;
3911 export function LDKMessageSendEvent_SendTxAbort_get_msg(ptr: bigint): bigint {
3912 if(!isWasmInitialized) {
3913 throw new Error("initializeWasm() must be awaited first!");
3915 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
3916 return nativeResponseValue;
3919 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
3920 if(!isWasmInitialized) {
3921 throw new Error("initializeWasm() must be awaited first!");
3923 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
3924 return nativeResponseValue;
3927 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
3932 return nativeResponseValue;
3935 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
3936 if(!isWasmInitialized) {
3937 throw new Error("initializeWasm() must be awaited first!");
3939 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
3940 return nativeResponseValue;
3943 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
3944 if(!isWasmInitialized) {
3945 throw new Error("initializeWasm() must be awaited first!");
3947 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
3948 return nativeResponseValue;
3951 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
3952 if(!isWasmInitialized) {
3953 throw new Error("initializeWasm() must be awaited first!");
3955 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
3956 return nativeResponseValue;
3959 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
3960 if(!isWasmInitialized) {
3961 throw new Error("initializeWasm() must be awaited first!");
3963 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
3964 return nativeResponseValue;
3967 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
3968 if(!isWasmInitialized) {
3969 throw new Error("initializeWasm() must be awaited first!");
3971 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
3972 return nativeResponseValue;
3975 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
3976 if(!isWasmInitialized) {
3977 throw new Error("initializeWasm() must be awaited first!");
3979 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
3980 return nativeResponseValue;
3983 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
3984 if(!isWasmInitialized) {
3985 throw new Error("initializeWasm() must be awaited first!");
3987 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
3988 return nativeResponseValue;
3991 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
3992 if(!isWasmInitialized) {
3993 throw new Error("initializeWasm() must be awaited first!");
3995 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
3996 return nativeResponseValue;
3999 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
4000 if(!isWasmInitialized) {
4001 throw new Error("initializeWasm() must be awaited first!");
4003 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
4004 return nativeResponseValue;
4007 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
4008 if(!isWasmInitialized) {
4009 throw new Error("initializeWasm() must be awaited first!");
4011 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
4012 return nativeResponseValue;
4015 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
4016 if(!isWasmInitialized) {
4017 throw new Error("initializeWasm() must be awaited first!");
4019 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
4020 return nativeResponseValue;
4023 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
4024 if(!isWasmInitialized) {
4025 throw new Error("initializeWasm() must be awaited first!");
4027 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
4028 return nativeResponseValue;
4031 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
4032 if(!isWasmInitialized) {
4033 throw new Error("initializeWasm() must be awaited first!");
4035 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
4036 return nativeResponseValue;
4039 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
4040 if(!isWasmInitialized) {
4041 throw new Error("initializeWasm() must be awaited first!");
4043 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
4044 return nativeResponseValue;
4047 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
4052 return nativeResponseValue;
4055 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
4060 return nativeResponseValue;
4063 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
4064 if(!isWasmInitialized) {
4065 throw new Error("initializeWasm() must be awaited first!");
4067 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
4068 return nativeResponseValue;
4071 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
4072 if(!isWasmInitialized) {
4073 throw new Error("initializeWasm() must be awaited first!");
4075 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
4076 return nativeResponseValue;
4079 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
4080 if(!isWasmInitialized) {
4081 throw new Error("initializeWasm() must be awaited first!");
4083 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
4084 return nativeResponseValue;
4087 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
4092 return nativeResponseValue;
4095 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
4096 if(!isWasmInitialized) {
4097 throw new Error("initializeWasm() must be awaited first!");
4099 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
4100 return nativeResponseValue;
4103 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
4104 if(!isWasmInitialized) {
4105 throw new Error("initializeWasm() must be awaited first!");
4107 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
4108 return nativeResponseValue;
4111 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
4112 if(!isWasmInitialized) {
4113 throw new Error("initializeWasm() must be awaited first!");
4115 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
4116 return nativeResponseValue;
4119 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
4120 if(!isWasmInitialized) {
4121 throw new Error("initializeWasm() must be awaited first!");
4123 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
4124 return nativeResponseValue;
4127 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
4128 if(!isWasmInitialized) {
4129 throw new Error("initializeWasm() must be awaited first!");
4131 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
4132 return nativeResponseValue;
4135 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
4136 if(!isWasmInitialized) {
4137 throw new Error("initializeWasm() must be awaited first!");
4139 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
4140 return nativeResponseValue;
4143 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
4144 if(!isWasmInitialized) {
4145 throw new Error("initializeWasm() must be awaited first!");
4147 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
4148 return nativeResponseValue;
4151 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
4152 if(!isWasmInitialized) {
4153 throw new Error("initializeWasm() must be awaited first!");
4155 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
4156 return nativeResponseValue;
4159 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
4160 if(!isWasmInitialized) {
4161 throw new Error("initializeWasm() must be awaited first!");
4163 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
4164 return nativeResponseValue;
4167 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
4168 if(!isWasmInitialized) {
4169 throw new Error("initializeWasm() must be awaited first!");
4171 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
4172 return nativeResponseValue;
4175 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
4176 if(!isWasmInitialized) {
4177 throw new Error("initializeWasm() must be awaited first!");
4179 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
4180 return nativeResponseValue;
4182 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4184 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4185 if(!isWasmInitialized) {
4186 throw new Error("initializeWasm() must be awaited first!");
4188 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
4189 return nativeResponseValue;
4191 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4193 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4194 if(!isWasmInitialized) {
4195 throw new Error("initializeWasm() must be awaited first!");
4197 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
4198 return nativeResponseValue;
4200 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4202 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4203 if(!isWasmInitialized) {
4204 throw new Error("initializeWasm() must be awaited first!");
4206 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
4207 return nativeResponseValue;
4209 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4211 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4212 if(!isWasmInitialized) {
4213 throw new Error("initializeWasm() must be awaited first!");
4215 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
4216 return nativeResponseValue;
4218 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4220 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
4225 return nativeResponseValue;
4227 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4229 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
4230 if(!isWasmInitialized) {
4231 throw new Error("initializeWasm() must be awaited first!");
4233 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
4234 return nativeResponseValue;
4237 export class LDKSocketAddress {
4238 protected constructor() {}
4241 export function LDKSocketAddress_ty_from_ptr(ptr: bigint): number {
4242 if(!isWasmInitialized) {
4243 throw new Error("initializeWasm() must be awaited first!");
4245 const nativeResponseValue = wasm.TS_LDKSocketAddress_ty_from_ptr(ptr);
4246 return nativeResponseValue;
4249 export function LDKSocketAddress_TcpIpV4_get_addr(ptr: bigint): number {
4250 if(!isWasmInitialized) {
4251 throw new Error("initializeWasm() must be awaited first!");
4253 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_addr(ptr);
4254 return nativeResponseValue;
4257 export function LDKSocketAddress_TcpIpV4_get_port(ptr: bigint): number {
4258 if(!isWasmInitialized) {
4259 throw new Error("initializeWasm() must be awaited first!");
4261 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_port(ptr);
4262 return nativeResponseValue;
4265 export function LDKSocketAddress_TcpIpV6_get_addr(ptr: bigint): number {
4266 if(!isWasmInitialized) {
4267 throw new Error("initializeWasm() must be awaited first!");
4269 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_addr(ptr);
4270 return nativeResponseValue;
4273 export function LDKSocketAddress_TcpIpV6_get_port(ptr: bigint): number {
4274 if(!isWasmInitialized) {
4275 throw new Error("initializeWasm() must be awaited first!");
4277 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_port(ptr);
4278 return nativeResponseValue;
4281 export function LDKSocketAddress_OnionV2_get_onion_v2(ptr: bigint): number {
4282 if(!isWasmInitialized) {
4283 throw new Error("initializeWasm() must be awaited first!");
4285 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV2_get_onion_v2(ptr);
4286 return nativeResponseValue;
4289 export function LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
4290 if(!isWasmInitialized) {
4291 throw new Error("initializeWasm() must be awaited first!");
4293 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr);
4294 return nativeResponseValue;
4297 export function LDKSocketAddress_OnionV3_get_checksum(ptr: bigint): number {
4298 if(!isWasmInitialized) {
4299 throw new Error("initializeWasm() must be awaited first!");
4301 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_checksum(ptr);
4302 return nativeResponseValue;
4305 export function LDKSocketAddress_OnionV3_get_version(ptr: bigint): number {
4306 if(!isWasmInitialized) {
4307 throw new Error("initializeWasm() must be awaited first!");
4309 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_version(ptr);
4310 return nativeResponseValue;
4313 export function LDKSocketAddress_OnionV3_get_port(ptr: bigint): number {
4314 if(!isWasmInitialized) {
4315 throw new Error("initializeWasm() must be awaited first!");
4317 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_port(ptr);
4318 return nativeResponseValue;
4321 export function LDKSocketAddress_Hostname_get_hostname(ptr: bigint): bigint {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_hostname(ptr);
4326 return nativeResponseValue;
4329 export function LDKSocketAddress_Hostname_get_port(ptr: bigint): number {
4330 if(!isWasmInitialized) {
4331 throw new Error("initializeWasm() must be awaited first!");
4333 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_port(ptr);
4334 return nativeResponseValue;
4336 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4338 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4339 if(!isWasmInitialized) {
4340 throw new Error("initializeWasm() must be awaited first!");
4342 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
4343 return nativeResponseValue;
4345 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4347 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4348 if(!isWasmInitialized) {
4349 throw new Error("initializeWasm() must be awaited first!");
4351 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
4352 return nativeResponseValue;
4354 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
4356 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
4357 if(!isWasmInitialized) {
4358 throw new Error("initializeWasm() must be awaited first!");
4360 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
4361 return nativeResponseValue;
4363 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
4365 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
4366 if(!isWasmInitialized) {
4367 throw new Error("initializeWasm() must be awaited first!");
4369 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
4370 return nativeResponseValue;
4372 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4374 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4375 if(!isWasmInitialized) {
4376 throw new Error("initializeWasm() must be awaited first!");
4378 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
4379 return nativeResponseValue;
4381 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4383 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4384 if(!isWasmInitialized) {
4385 throw new Error("initializeWasm() must be awaited first!");
4387 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
4388 return nativeResponseValue;
4390 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4392 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
4393 if(!isWasmInitialized) {
4394 throw new Error("initializeWasm() must be awaited first!");
4396 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
4397 return nativeResponseValue;
4399 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4401 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
4402 if(!isWasmInitialized) {
4403 throw new Error("initializeWasm() must be awaited first!");
4405 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
4406 return nativeResponseValue;
4409 export class LDKCOption_CVec_SocketAddressZZ {
4410 protected constructor() {}
4413 export function LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr: bigint): number {
4414 if(!isWasmInitialized) {
4415 throw new Error("initializeWasm() must be awaited first!");
4417 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr);
4418 return nativeResponseValue;
4421 export function LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr: bigint): number {
4422 if(!isWasmInitialized) {
4423 throw new Error("initializeWasm() must be awaited first!");
4425 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr);
4426 return nativeResponseValue;
4428 // uint64_t CResult_u64ShortChannelIdErrorZ_get_ok(LDKCResult_u64ShortChannelIdErrorZ *NONNULL_PTR owner);
4430 export function CResult_u64ShortChannelIdErrorZ_get_ok(owner: bigint): bigint {
4431 if(!isWasmInitialized) {
4432 throw new Error("initializeWasm() must be awaited first!");
4434 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_get_ok(owner);
4435 return nativeResponseValue;
4437 // enum LDKShortChannelIdError CResult_u64ShortChannelIdErrorZ_get_err(LDKCResult_u64ShortChannelIdErrorZ *NONNULL_PTR owner);
4439 export function CResult_u64ShortChannelIdErrorZ_get_err(owner: bigint): ShortChannelIdError {
4440 if(!isWasmInitialized) {
4441 throw new Error("initializeWasm() must be awaited first!");
4443 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_get_err(owner);
4444 return nativeResponseValue;
4446 // struct LDKPendingHTLCInfo CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR owner);
4448 export function CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(owner: bigint): bigint {
4449 if(!isWasmInitialized) {
4450 throw new Error("initializeWasm() must be awaited first!");
4452 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(owner);
4453 return nativeResponseValue;
4455 // struct LDKInboundHTLCErr CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR owner);
4457 export function CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(owner: bigint): bigint {
4458 if(!isWasmInitialized) {
4459 throw new Error("initializeWasm() must be awaited first!");
4461 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(owner);
4462 return nativeResponseValue;
4465 export class LDKCOption_TxOutZ {
4466 protected constructor() {}
4469 export function LDKCOption_TxOutZ_ty_from_ptr(ptr: bigint): number {
4470 if(!isWasmInitialized) {
4471 throw new Error("initializeWasm() must be awaited first!");
4473 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_ty_from_ptr(ptr);
4474 return nativeResponseValue;
4477 export function LDKCOption_TxOutZ_Some_get_some(ptr: bigint): bigint {
4478 if(!isWasmInitialized) {
4479 throw new Error("initializeWasm() must be awaited first!");
4481 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_Some_get_some(ptr);
4482 return nativeResponseValue;
4484 // struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
4486 export function CResult_CoinSelectionNoneZ_get_ok(owner: bigint): bigint {
4487 if(!isWasmInitialized) {
4488 throw new Error("initializeWasm() must be awaited first!");
4490 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_ok(owner);
4491 return nativeResponseValue;
4493 // void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
4495 export function CResult_CoinSelectionNoneZ_get_err(owner: bigint): void {
4496 if(!isWasmInitialized) {
4497 throw new Error("initializeWasm() must be awaited first!");
4499 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_err(owner);
4500 // debug statements here
4502 // struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
4504 export function CResult_CVec_UtxoZNoneZ_get_ok(owner: bigint): number {
4505 if(!isWasmInitialized) {
4506 throw new Error("initializeWasm() must be awaited first!");
4508 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_ok(owner);
4509 return nativeResponseValue;
4511 // void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
4513 export function CResult_CVec_UtxoZNoneZ_get_err(owner: bigint): void {
4514 if(!isWasmInitialized) {
4515 throw new Error("initializeWasm() must be awaited first!");
4517 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_err(owner);
4518 // debug statements here
4521 export class LDKPaymentContext {
4522 protected constructor() {}
4525 export function LDKPaymentContext_ty_from_ptr(ptr: bigint): number {
4526 if(!isWasmInitialized) {
4527 throw new Error("initializeWasm() must be awaited first!");
4529 const nativeResponseValue = wasm.TS_LDKPaymentContext_ty_from_ptr(ptr);
4530 return nativeResponseValue;
4533 export function LDKPaymentContext_Unknown_get_unknown(ptr: bigint): bigint {
4534 if(!isWasmInitialized) {
4535 throw new Error("initializeWasm() must be awaited first!");
4537 const nativeResponseValue = wasm.TS_LDKPaymentContext_Unknown_get_unknown(ptr);
4538 return nativeResponseValue;
4541 export function LDKPaymentContext_Bolt12Offer_get_bolt12_offer(ptr: bigint): bigint {
4542 if(!isWasmInitialized) {
4543 throw new Error("initializeWasm() must be awaited first!");
4545 const nativeResponseValue = wasm.TS_LDKPaymentContext_Bolt12Offer_get_bolt12_offer(ptr);
4546 return nativeResponseValue;
4549 export function LDKPaymentContext_Bolt12Refund_get_bolt12_refund(ptr: bigint): bigint {
4550 if(!isWasmInitialized) {
4551 throw new Error("initializeWasm() must be awaited first!");
4553 const nativeResponseValue = wasm.TS_LDKPaymentContext_Bolt12Refund_get_bolt12_refund(ptr);
4554 return nativeResponseValue;
4557 export class LDKCOption_PaymentContextZ {
4558 protected constructor() {}
4561 export function LDKCOption_PaymentContextZ_ty_from_ptr(ptr: bigint): number {
4562 if(!isWasmInitialized) {
4563 throw new Error("initializeWasm() must be awaited first!");
4565 const nativeResponseValue = wasm.TS_LDKCOption_PaymentContextZ_ty_from_ptr(ptr);
4566 return nativeResponseValue;
4569 export function LDKCOption_PaymentContextZ_Some_get_some(ptr: bigint): bigint {
4570 if(!isWasmInitialized) {
4571 throw new Error("initializeWasm() must be awaited first!");
4573 const nativeResponseValue = wasm.TS_LDKCOption_PaymentContextZ_Some_get_some(ptr);
4574 return nativeResponseValue;
4576 // uint64_t C2Tuple_u64u16Z_get_a(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4578 export function C2Tuple_u64u16Z_get_a(owner: bigint): bigint {
4579 if(!isWasmInitialized) {
4580 throw new Error("initializeWasm() must be awaited first!");
4582 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_a(owner);
4583 return nativeResponseValue;
4585 // uint16_t C2Tuple_u64u16Z_get_b(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4587 export function C2Tuple_u64u16Z_get_b(owner: bigint): number {
4588 if(!isWasmInitialized) {
4589 throw new Error("initializeWasm() must be awaited first!");
4591 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_b(owner);
4592 return nativeResponseValue;
4595 export class LDKCOption_C2Tuple_u64u16ZZ {
4596 protected constructor() {}
4599 export function LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr: bigint): number {
4600 if(!isWasmInitialized) {
4601 throw new Error("initializeWasm() must be awaited first!");
4603 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr);
4604 return nativeResponseValue;
4607 export function LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr: bigint): bigint {
4608 if(!isWasmInitialized) {
4609 throw new Error("initializeWasm() must be awaited first!");
4611 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr);
4612 return nativeResponseValue;
4615 export class LDKCOption_ChannelShutdownStateZ {
4616 protected constructor() {}
4619 export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
4620 if(!isWasmInitialized) {
4621 throw new Error("initializeWasm() must be awaited first!");
4623 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
4624 return nativeResponseValue;
4627 export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
4628 if(!isWasmInitialized) {
4629 throw new Error("initializeWasm() must be awaited first!");
4631 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
4632 return nativeResponseValue;
4634 // struct LDKChannelId CResult_ChannelIdAPIErrorZ_get_ok(LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR owner);
4636 export function CResult_ChannelIdAPIErrorZ_get_ok(owner: bigint): bigint {
4637 if(!isWasmInitialized) {
4638 throw new Error("initializeWasm() must be awaited first!");
4640 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_get_ok(owner);
4641 return nativeResponseValue;
4643 // struct LDKAPIError CResult_ChannelIdAPIErrorZ_get_err(LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR owner);
4645 export function CResult_ChannelIdAPIErrorZ_get_err(owner: bigint): bigint {
4646 if(!isWasmInitialized) {
4647 throw new Error("initializeWasm() must be awaited first!");
4649 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_get_err(owner);
4650 return nativeResponseValue;
4653 export class LDKRecentPaymentDetails {
4654 protected constructor() {}
4657 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
4658 if(!isWasmInitialized) {
4659 throw new Error("initializeWasm() must be awaited first!");
4661 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
4662 return nativeResponseValue;
4665 export function LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr: bigint): number {
4666 if(!isWasmInitialized) {
4667 throw new Error("initializeWasm() must be awaited first!");
4669 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr);
4670 return nativeResponseValue;
4673 export function LDKRecentPaymentDetails_Pending_get_payment_id(ptr: bigint): number {
4674 if(!isWasmInitialized) {
4675 throw new Error("initializeWasm() must be awaited first!");
4677 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_id(ptr);
4678 return nativeResponseValue;
4681 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
4682 if(!isWasmInitialized) {
4683 throw new Error("initializeWasm() must be awaited first!");
4685 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
4686 return nativeResponseValue;
4689 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
4690 if(!isWasmInitialized) {
4691 throw new Error("initializeWasm() must be awaited first!");
4693 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
4694 return nativeResponseValue;
4697 export function LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr: bigint): number {
4698 if(!isWasmInitialized) {
4699 throw new Error("initializeWasm() must be awaited first!");
4701 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr);
4702 return nativeResponseValue;
4705 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): bigint {
4706 if(!isWasmInitialized) {
4707 throw new Error("initializeWasm() must be awaited first!");
4709 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
4710 return nativeResponseValue;
4713 export function LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr: bigint): number {
4714 if(!isWasmInitialized) {
4715 throw new Error("initializeWasm() must be awaited first!");
4717 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr);
4718 return nativeResponseValue;
4721 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
4722 if(!isWasmInitialized) {
4723 throw new Error("initializeWasm() must be awaited first!");
4725 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
4726 return nativeResponseValue;
4729 export class LDKPaymentSendFailure {
4730 protected constructor() {}
4733 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4734 if(!isWasmInitialized) {
4735 throw new Error("initializeWasm() must be awaited first!");
4737 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4738 return nativeResponseValue;
4741 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4742 if(!isWasmInitialized) {
4743 throw new Error("initializeWasm() must be awaited first!");
4745 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4746 return nativeResponseValue;
4749 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4750 if(!isWasmInitialized) {
4751 throw new Error("initializeWasm() must be awaited first!");
4753 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4754 return nativeResponseValue;
4757 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4758 if(!isWasmInitialized) {
4759 throw new Error("initializeWasm() must be awaited first!");
4761 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4762 return nativeResponseValue;
4765 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4766 if(!isWasmInitialized) {
4767 throw new Error("initializeWasm() must be awaited first!");
4769 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4770 return nativeResponseValue;
4773 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4774 if(!isWasmInitialized) {
4775 throw new Error("initializeWasm() must be awaited first!");
4777 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4778 return nativeResponseValue;
4781 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4782 if(!isWasmInitialized) {
4783 throw new Error("initializeWasm() must be awaited first!");
4785 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4786 return nativeResponseValue;
4788 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4790 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4791 if(!isWasmInitialized) {
4792 throw new Error("initializeWasm() must be awaited first!");
4794 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4795 // debug statements here
4797 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4799 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4800 if(!isWasmInitialized) {
4801 throw new Error("initializeWasm() must be awaited first!");
4803 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4804 return nativeResponseValue;
4806 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4808 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
4813 // debug statements here
4815 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4817 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4818 if(!isWasmInitialized) {
4819 throw new Error("initializeWasm() must be awaited first!");
4821 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
4822 return nativeResponseValue;
4824 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4826 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner: bigint): number {
4827 if(!isWasmInitialized) {
4828 throw new Error("initializeWasm() must be awaited first!");
4830 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner);
4831 return nativeResponseValue;
4833 // struct LDKPaymentSendFailure CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4835 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner: bigint): bigint {
4836 if(!isWasmInitialized) {
4837 throw new Error("initializeWasm() must be awaited first!");
4839 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner);
4840 return nativeResponseValue;
4842 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4844 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner: bigint): number {
4845 if(!isWasmInitialized) {
4846 throw new Error("initializeWasm() must be awaited first!");
4848 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner);
4849 return nativeResponseValue;
4851 // enum LDKRetryableSendFailure CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4853 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4854 if(!isWasmInitialized) {
4855 throw new Error("initializeWasm() must be awaited first!");
4857 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner);
4858 return nativeResponseValue;
4860 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4862 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner: bigint): number {
4863 if(!isWasmInitialized) {
4864 throw new Error("initializeWasm() must be awaited first!");
4866 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner);
4867 return nativeResponseValue;
4869 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4871 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner: bigint): number {
4872 if(!isWasmInitialized) {
4873 throw new Error("initializeWasm() must be awaited first!");
4875 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner);
4876 return nativeResponseValue;
4878 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4880 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4881 if(!isWasmInitialized) {
4882 throw new Error("initializeWasm() must be awaited first!");
4884 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner);
4885 return nativeResponseValue;
4887 // struct LDKPaymentSendFailure CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4889 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4890 if(!isWasmInitialized) {
4891 throw new Error("initializeWasm() must be awaited first!");
4893 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner);
4894 return nativeResponseValue;
4897 export class LDKProbeSendFailure {
4898 protected constructor() {}
4901 export function LDKProbeSendFailure_ty_from_ptr(ptr: bigint): number {
4902 if(!isWasmInitialized) {
4903 throw new Error("initializeWasm() must be awaited first!");
4905 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_ty_from_ptr(ptr);
4906 return nativeResponseValue;
4909 export function LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr: bigint): bigint {
4910 if(!isWasmInitialized) {
4911 throw new Error("initializeWasm() must be awaited first!");
4913 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr);
4914 return nativeResponseValue;
4916 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4918 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner: bigint): number {
4919 if(!isWasmInitialized) {
4920 throw new Error("initializeWasm() must be awaited first!");
4922 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner);
4923 return nativeResponseValue;
4925 // struct LDKProbeSendFailure CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4927 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner: bigint): bigint {
4928 if(!isWasmInitialized) {
4929 throw new Error("initializeWasm() must be awaited first!");
4931 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner);
4932 return nativeResponseValue;
4934 // struct LDKChannelId C2Tuple_ChannelIdPublicKeyZ_get_a(LDKC2Tuple_ChannelIdPublicKeyZ *NONNULL_PTR owner);
4936 export function C2Tuple_ChannelIdPublicKeyZ_get_a(owner: bigint): bigint {
4937 if(!isWasmInitialized) {
4938 throw new Error("initializeWasm() must be awaited first!");
4940 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_get_a(owner);
4941 return nativeResponseValue;
4943 // struct LDKPublicKey C2Tuple_ChannelIdPublicKeyZ_get_b(LDKC2Tuple_ChannelIdPublicKeyZ *NONNULL_PTR owner);
4945 export function C2Tuple_ChannelIdPublicKeyZ_get_b(owner: bigint): number {
4946 if(!isWasmInitialized) {
4947 throw new Error("initializeWasm() must be awaited first!");
4949 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_get_b(owner);
4950 return nativeResponseValue;
4952 // struct LDKOfferWithDerivedMetadataBuilder CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
4954 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
4955 if(!isWasmInitialized) {
4956 throw new Error("initializeWasm() must be awaited first!");
4958 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_ok(owner);
4959 return nativeResponseValue;
4961 // enum LDKBolt12SemanticError CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
4963 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
4964 if(!isWasmInitialized) {
4965 throw new Error("initializeWasm() must be awaited first!");
4967 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_get_err(owner);
4968 return nativeResponseValue;
4971 export class LDKCOption_StrZ {
4972 protected constructor() {}
4975 export function LDKCOption_StrZ_ty_from_ptr(ptr: bigint): number {
4976 if(!isWasmInitialized) {
4977 throw new Error("initializeWasm() must be awaited first!");
4979 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_ty_from_ptr(ptr);
4980 return nativeResponseValue;
4983 export function LDKCOption_StrZ_Some_get_some(ptr: bigint): number {
4984 if(!isWasmInitialized) {
4985 throw new Error("initializeWasm() must be awaited first!");
4987 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_Some_get_some(ptr);
4988 return nativeResponseValue;
4990 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4992 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner: bigint): bigint {
4993 if(!isWasmInitialized) {
4994 throw new Error("initializeWasm() must be awaited first!");
4996 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner);
4997 return nativeResponseValue;
4999 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
5001 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner: bigint): void {
5002 if(!isWasmInitialized) {
5003 throw new Error("initializeWasm() must be awaited first!");
5005 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner);
5006 // debug statements here
5008 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesAPIErrorZ_get_ok(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
5010 export function CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner: bigint): number {
5011 if(!isWasmInitialized) {
5012 throw new Error("initializeWasm() must be awaited first!");
5014 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner);
5015 return nativeResponseValue;
5017 // struct LDKAPIError CResult_ThirtyTwoBytesAPIErrorZ_get_err(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
5019 export function CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner: bigint): bigint {
5020 if(!isWasmInitialized) {
5021 throw new Error("initializeWasm() must be awaited first!");
5023 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner);
5024 return nativeResponseValue;
5027 export class LDKOffersMessage {
5028 protected constructor() {}
5031 export function LDKOffersMessage_ty_from_ptr(ptr: bigint): number {
5032 if(!isWasmInitialized) {
5033 throw new Error("initializeWasm() must be awaited first!");
5035 const nativeResponseValue = wasm.TS_LDKOffersMessage_ty_from_ptr(ptr);
5036 return nativeResponseValue;
5039 export function LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr: bigint): bigint {
5040 if(!isWasmInitialized) {
5041 throw new Error("initializeWasm() must be awaited first!");
5043 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
5044 return nativeResponseValue;
5047 export function LDKOffersMessage_Invoice_get_invoice(ptr: bigint): bigint {
5048 if(!isWasmInitialized) {
5049 throw new Error("initializeWasm() must be awaited first!");
5051 const nativeResponseValue = wasm.TS_LDKOffersMessage_Invoice_get_invoice(ptr);
5052 return nativeResponseValue;
5055 export function LDKOffersMessage_InvoiceError_get_invoice_error(ptr: bigint): bigint {
5056 if(!isWasmInitialized) {
5057 throw new Error("initializeWasm() must be awaited first!");
5059 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
5060 return nativeResponseValue;
5063 export class LDKCOption_OffersMessageZ {
5064 protected constructor() {}
5067 export function LDKCOption_OffersMessageZ_ty_from_ptr(ptr: bigint): number {
5068 if(!isWasmInitialized) {
5069 throw new Error("initializeWasm() must be awaited first!");
5071 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_ty_from_ptr(ptr);
5072 return nativeResponseValue;
5075 export function LDKCOption_OffersMessageZ_Some_get_some(ptr: bigint): bigint {
5076 if(!isWasmInitialized) {
5077 throw new Error("initializeWasm() must be awaited first!");
5079 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_Some_get_some(ptr);
5080 return nativeResponseValue;
5083 export class LDKDestination {
5084 protected constructor() {}
5087 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
5088 if(!isWasmInitialized) {
5089 throw new Error("initializeWasm() must be awaited first!");
5091 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
5092 return nativeResponseValue;
5095 export function LDKDestination_Node_get_node(ptr: bigint): number {
5096 if(!isWasmInitialized) {
5097 throw new Error("initializeWasm() must be awaited first!");
5099 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
5100 return nativeResponseValue;
5103 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
5104 if(!isWasmInitialized) {
5105 throw new Error("initializeWasm() must be awaited first!");
5107 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
5108 return nativeResponseValue;
5110 // struct LDKOffersMessage C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
5112 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner: bigint): bigint {
5113 if(!isWasmInitialized) {
5114 throw new Error("initializeWasm() must be awaited first!");
5116 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner);
5117 return nativeResponseValue;
5119 // struct LDKDestination C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
5121 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner: bigint): bigint {
5122 if(!isWasmInitialized) {
5123 throw new Error("initializeWasm() must be awaited first!");
5125 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner);
5126 return nativeResponseValue;
5128 // struct LDKBlindedPath C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
5130 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner: bigint): bigint {
5131 if(!isWasmInitialized) {
5132 throw new Error("initializeWasm() must be awaited first!");
5134 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner);
5135 return nativeResponseValue;
5137 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
5139 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
5140 if(!isWasmInitialized) {
5141 throw new Error("initializeWasm() must be awaited first!");
5143 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
5144 return nativeResponseValue;
5146 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
5148 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5149 if(!isWasmInitialized) {
5150 throw new Error("initializeWasm() must be awaited first!");
5152 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
5153 return nativeResponseValue;
5155 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
5157 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
5158 if(!isWasmInitialized) {
5159 throw new Error("initializeWasm() must be awaited first!");
5161 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
5162 return nativeResponseValue;
5164 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
5166 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
5167 if(!isWasmInitialized) {
5168 throw new Error("initializeWasm() must be awaited first!");
5170 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
5171 return nativeResponseValue;
5173 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
5175 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
5176 if(!isWasmInitialized) {
5177 throw new Error("initializeWasm() must be awaited first!");
5179 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
5180 return nativeResponseValue;
5182 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
5184 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
5185 if(!isWasmInitialized) {
5186 throw new Error("initializeWasm() must be awaited first!");
5188 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
5189 return nativeResponseValue;
5191 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
5193 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
5194 if(!isWasmInitialized) {
5195 throw new Error("initializeWasm() must be awaited first!");
5197 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
5198 return nativeResponseValue;
5200 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
5202 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
5203 if(!isWasmInitialized) {
5204 throw new Error("initializeWasm() must be awaited first!");
5206 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
5207 return nativeResponseValue;
5209 // struct LDKBlindedForward CResult_BlindedForwardDecodeErrorZ_get_ok(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR owner);
5211 export function CResult_BlindedForwardDecodeErrorZ_get_ok(owner: bigint): bigint {
5212 if(!isWasmInitialized) {
5213 throw new Error("initializeWasm() must be awaited first!");
5215 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_get_ok(owner);
5216 return nativeResponseValue;
5218 // struct LDKDecodeError CResult_BlindedForwardDecodeErrorZ_get_err(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR owner);
5220 export function CResult_BlindedForwardDecodeErrorZ_get_err(owner: bigint): bigint {
5221 if(!isWasmInitialized) {
5222 throw new Error("initializeWasm() must be awaited first!");
5224 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_get_err(owner);
5225 return nativeResponseValue;
5228 export class LDKPendingHTLCRouting {
5229 protected constructor() {}
5232 export function LDKPendingHTLCRouting_ty_from_ptr(ptr: bigint): number {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ty_from_ptr(ptr);
5237 return nativeResponseValue;
5240 export function LDKPendingHTLCRouting_Forward_get_onion_packet(ptr: bigint): bigint {
5241 if(!isWasmInitialized) {
5242 throw new Error("initializeWasm() must be awaited first!");
5244 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_onion_packet(ptr);
5245 return nativeResponseValue;
5248 export function LDKPendingHTLCRouting_Forward_get_short_channel_id(ptr: bigint): bigint {
5249 if(!isWasmInitialized) {
5250 throw new Error("initializeWasm() must be awaited first!");
5252 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_short_channel_id(ptr);
5253 return nativeResponseValue;
5256 export function LDKPendingHTLCRouting_Forward_get_blinded(ptr: bigint): bigint {
5257 if(!isWasmInitialized) {
5258 throw new Error("initializeWasm() must be awaited first!");
5260 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_blinded(ptr);
5261 return nativeResponseValue;
5264 export function LDKPendingHTLCRouting_Receive_get_payment_data(ptr: bigint): bigint {
5265 if(!isWasmInitialized) {
5266 throw new Error("initializeWasm() must be awaited first!");
5268 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_payment_data(ptr);
5269 return nativeResponseValue;
5272 export function LDKPendingHTLCRouting_Receive_get_payment_metadata(ptr: bigint): bigint {
5273 if(!isWasmInitialized) {
5274 throw new Error("initializeWasm() must be awaited first!");
5276 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_payment_metadata(ptr);
5277 return nativeResponseValue;
5280 export function LDKPendingHTLCRouting_Receive_get_payment_context(ptr: bigint): bigint {
5281 if(!isWasmInitialized) {
5282 throw new Error("initializeWasm() must be awaited first!");
5284 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_payment_context(ptr);
5285 return nativeResponseValue;
5288 export function LDKPendingHTLCRouting_Receive_get_incoming_cltv_expiry(ptr: bigint): number {
5289 if(!isWasmInitialized) {
5290 throw new Error("initializeWasm() must be awaited first!");
5292 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_incoming_cltv_expiry(ptr);
5293 return nativeResponseValue;
5296 export function LDKPendingHTLCRouting_Receive_get_phantom_shared_secret(ptr: bigint): number {
5297 if(!isWasmInitialized) {
5298 throw new Error("initializeWasm() must be awaited first!");
5300 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_phantom_shared_secret(ptr);
5301 return nativeResponseValue;
5304 export function LDKPendingHTLCRouting_Receive_get_custom_tlvs(ptr: bigint): number {
5305 if(!isWasmInitialized) {
5306 throw new Error("initializeWasm() must be awaited first!");
5308 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_custom_tlvs(ptr);
5309 return nativeResponseValue;
5312 export function LDKPendingHTLCRouting_Receive_get_requires_blinded_error(ptr: bigint): boolean {
5313 if(!isWasmInitialized) {
5314 throw new Error("initializeWasm() must be awaited first!");
5316 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_requires_blinded_error(ptr);
5317 return nativeResponseValue;
5320 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_data(ptr: bigint): bigint {
5321 if(!isWasmInitialized) {
5322 throw new Error("initializeWasm() must be awaited first!");
5324 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_data(ptr);
5325 return nativeResponseValue;
5328 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_preimage(ptr: bigint): number {
5329 if(!isWasmInitialized) {
5330 throw new Error("initializeWasm() must be awaited first!");
5332 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_preimage(ptr);
5333 return nativeResponseValue;
5336 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_metadata(ptr: bigint): bigint {
5337 if(!isWasmInitialized) {
5338 throw new Error("initializeWasm() must be awaited first!");
5340 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_metadata(ptr);
5341 return nativeResponseValue;
5344 export function LDKPendingHTLCRouting_ReceiveKeysend_get_incoming_cltv_expiry(ptr: bigint): number {
5345 if(!isWasmInitialized) {
5346 throw new Error("initializeWasm() must be awaited first!");
5348 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_incoming_cltv_expiry(ptr);
5349 return nativeResponseValue;
5352 export function LDKPendingHTLCRouting_ReceiveKeysend_get_custom_tlvs(ptr: bigint): number {
5353 if(!isWasmInitialized) {
5354 throw new Error("initializeWasm() must be awaited first!");
5356 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_custom_tlvs(ptr);
5357 return nativeResponseValue;
5360 export function LDKPendingHTLCRouting_ReceiveKeysend_get_requires_blinded_error(ptr: bigint): boolean {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_requires_blinded_error(ptr);
5365 return nativeResponseValue;
5367 // struct LDKPendingHTLCRouting CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR owner);
5369 export function CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(owner: bigint): bigint {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(owner);
5374 return nativeResponseValue;
5376 // struct LDKDecodeError CResult_PendingHTLCRoutingDecodeErrorZ_get_err(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR owner);
5378 export function CResult_PendingHTLCRoutingDecodeErrorZ_get_err(owner: bigint): bigint {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_get_err(owner);
5383 return nativeResponseValue;
5385 // struct LDKPendingHTLCInfo CResult_PendingHTLCInfoDecodeErrorZ_get_ok(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR owner);
5387 export function CResult_PendingHTLCInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_get_ok(owner);
5392 return nativeResponseValue;
5394 // struct LDKDecodeError CResult_PendingHTLCInfoDecodeErrorZ_get_err(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR owner);
5396 export function CResult_PendingHTLCInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_get_err(owner);
5401 return nativeResponseValue;
5403 // enum LDKBlindedFailure CResult_BlindedFailureDecodeErrorZ_get_ok(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR owner);
5405 export function CResult_BlindedFailureDecodeErrorZ_get_ok(owner: bigint): BlindedFailure {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_get_ok(owner);
5410 return nativeResponseValue;
5412 // struct LDKDecodeError CResult_BlindedFailureDecodeErrorZ_get_err(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR owner);
5414 export function CResult_BlindedFailureDecodeErrorZ_get_err(owner: bigint): bigint {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_get_err(owner);
5419 return nativeResponseValue;
5421 // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
5423 export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
5428 return nativeResponseValue;
5430 // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
5432 export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
5437 return nativeResponseValue;
5440 export interface LDKWatch {
5441 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
5442 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
5443 release_pending_monitor_events (): number;
5447 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
5448 if(!isWasmInitialized) {
5449 throw new Error("initializeWasm() must be awaited first!");
5451 var new_obj_idx = js_objs.length;
5452 for (var i = 0; i < js_objs.length; i++) {
5453 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5455 js_objs[i] = new WeakRef(impl);
5456 return [wasm.TS_LDKWatch_new(i), i];
5458 // LDKCResult_ChannelMonitorUpdateStatusNoneZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
5460 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
5461 if(!isWasmInitialized) {
5462 throw new Error("initializeWasm() must be awaited first!");
5464 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
5465 return nativeResponseValue;
5467 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
5469 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
5470 if(!isWasmInitialized) {
5471 throw new Error("initializeWasm() must be awaited first!");
5473 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
5474 return nativeResponseValue;
5476 // LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
5478 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
5479 if(!isWasmInitialized) {
5480 throw new Error("initializeWasm() must be awaited first!");
5482 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
5483 return nativeResponseValue;
5486 export interface LDKBroadcasterInterface {
5487 broadcast_transactions (txs: number): void;
5491 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
5492 if(!isWasmInitialized) {
5493 throw new Error("initializeWasm() must be awaited first!");
5495 var new_obj_idx = js_objs.length;
5496 for (var i = 0; i < js_objs.length; i++) {
5497 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5499 js_objs[i] = new WeakRef(impl);
5500 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
5502 // void BroadcasterInterface_broadcast_transactions LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKCVec_TransactionZ txs
5504 export function BroadcasterInterface_broadcast_transactions(this_arg: bigint, txs: number): void {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transactions(this_arg, txs);
5509 // debug statements here
5512 export interface LDKEntropySource {
5513 get_secure_random_bytes (): number;
5517 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
5518 if(!isWasmInitialized) {
5519 throw new Error("initializeWasm() must be awaited first!");
5521 var new_obj_idx = js_objs.length;
5522 for (var i = 0; i < js_objs.length; i++) {
5523 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5525 js_objs[i] = new WeakRef(impl);
5526 return [wasm.TS_LDKEntropySource_new(i), i];
5528 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
5530 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
5531 if(!isWasmInitialized) {
5532 throw new Error("initializeWasm() must be awaited first!");
5534 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
5535 return nativeResponseValue;
5538 export class LDKUnsignedGossipMessage {
5539 protected constructor() {}
5542 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
5543 if(!isWasmInitialized) {
5544 throw new Error("initializeWasm() must be awaited first!");
5546 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
5547 return nativeResponseValue;
5550 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
5551 if(!isWasmInitialized) {
5552 throw new Error("initializeWasm() must be awaited first!");
5554 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
5555 return nativeResponseValue;
5558 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
5563 return nativeResponseValue;
5566 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
5567 if(!isWasmInitialized) {
5568 throw new Error("initializeWasm() must be awaited first!");
5570 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
5571 return nativeResponseValue;
5574 export interface LDKNodeSigner {
5575 get_inbound_payment_key_material (): number;
5576 get_node_id (recipient: Recipient): bigint;
5577 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
5578 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
5579 sign_bolt12_invoice_request (invoice_request: bigint): bigint;
5580 sign_bolt12_invoice (invoice: bigint): bigint;
5581 sign_gossip_message (msg: bigint): bigint;
5585 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 var new_obj_idx = js_objs.length;
5590 for (var i = 0; i < js_objs.length; i++) {
5591 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5593 js_objs[i] = new WeakRef(impl);
5594 return [wasm.TS_LDKNodeSigner_new(i), i];
5596 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
5598 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
5599 if(!isWasmInitialized) {
5600 throw new Error("initializeWasm() must be awaited first!");
5602 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
5603 return nativeResponseValue;
5605 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
5607 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
5608 if(!isWasmInitialized) {
5609 throw new Error("initializeWasm() must be awaited first!");
5611 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
5612 return nativeResponseValue;
5614 // LDKCResult_ThirtyTwoBytesNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak
5616 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
5617 if(!isWasmInitialized) {
5618 throw new Error("initializeWasm() must be awaited first!");
5620 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
5621 return nativeResponseValue;
5623 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
5625 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
5626 if(!isWasmInitialized) {
5627 throw new Error("initializeWasm() must be awaited first!");
5629 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
5630 return nativeResponseValue;
5632 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice_request LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request
5634 export function NodeSigner_sign_bolt12_invoice_request(this_arg: bigint, invoice_request: bigint): bigint {
5635 if(!isWasmInitialized) {
5636 throw new Error("initializeWasm() must be awaited first!");
5638 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice_request(this_arg, invoice_request);
5639 return nativeResponseValue;
5641 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice
5643 export function NodeSigner_sign_bolt12_invoice(this_arg: bigint, invoice: bigint): bigint {
5644 if(!isWasmInitialized) {
5645 throw new Error("initializeWasm() must be awaited first!");
5647 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice(this_arg, invoice);
5648 return nativeResponseValue;
5650 // LDKCResult_ECDSASignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
5652 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
5653 if(!isWasmInitialized) {
5654 throw new Error("initializeWasm() must be awaited first!");
5656 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
5657 return nativeResponseValue;
5660 export interface LDKSignerProvider {
5661 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
5662 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
5663 read_chan_signer (reader: number): bigint;
5664 get_destination_script (channel_keys_id: number): bigint;
5665 get_shutdown_scriptpubkey (): bigint;
5669 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
5670 if(!isWasmInitialized) {
5671 throw new Error("initializeWasm() must be awaited first!");
5673 var new_obj_idx = js_objs.length;
5674 for (var i = 0; i < js_objs.length; i++) {
5675 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5677 js_objs[i] = new WeakRef(impl);
5678 return [wasm.TS_LDKSignerProvider_new(i), i];
5680 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
5682 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
5683 if(!isWasmInitialized) {
5684 throw new Error("initializeWasm() must be awaited first!");
5686 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
5687 return nativeResponseValue;
5689 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
5691 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
5692 if(!isWasmInitialized) {
5693 throw new Error("initializeWasm() must be awaited first!");
5695 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
5696 return nativeResponseValue;
5698 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
5700 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
5701 if(!isWasmInitialized) {
5702 throw new Error("initializeWasm() must be awaited first!");
5704 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
5705 return nativeResponseValue;
5707 // LDKCResult_CVec_u8ZNoneZ SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes channel_keys_id
5709 export function SignerProvider_get_destination_script(this_arg: bigint, channel_keys_id: number): bigint {
5710 if(!isWasmInitialized) {
5711 throw new Error("initializeWasm() must be awaited first!");
5713 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg, channel_keys_id);
5714 return nativeResponseValue;
5716 // LDKCResult_ShutdownScriptNoneZ SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
5718 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
5719 if(!isWasmInitialized) {
5720 throw new Error("initializeWasm() must be awaited first!");
5722 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
5723 return nativeResponseValue;
5726 export interface LDKFeeEstimator {
5727 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
5731 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
5732 if(!isWasmInitialized) {
5733 throw new Error("initializeWasm() must be awaited first!");
5735 var new_obj_idx = js_objs.length;
5736 for (var i = 0; i < js_objs.length; i++) {
5737 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5739 js_objs[i] = new WeakRef(impl);
5740 return [wasm.TS_LDKFeeEstimator_new(i), i];
5742 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
5744 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
5745 if(!isWasmInitialized) {
5746 throw new Error("initializeWasm() must be awaited first!");
5748 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
5749 return nativeResponseValue;
5752 export interface LDKMessageRouter {
5753 find_path (sender: number, peers: number, destination: bigint): bigint;
5754 create_blinded_paths (recipient: number, peers: number): bigint;
5758 export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
5759 if(!isWasmInitialized) {
5760 throw new Error("initializeWasm() must be awaited first!");
5762 var new_obj_idx = js_objs.length;
5763 for (var i = 0; i < js_objs.length; i++) {
5764 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5766 js_objs[i] = new WeakRef(impl);
5767 return [wasm.TS_LDKMessageRouter_new(i), i];
5769 // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
5771 export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
5772 if(!isWasmInitialized) {
5773 throw new Error("initializeWasm() must be awaited first!");
5775 const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
5776 return nativeResponseValue;
5778 // LDKCResult_CVec_BlindedPathZNoneZ MessageRouter_create_blinded_paths LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers
5780 export function MessageRouter_create_blinded_paths(this_arg: bigint, recipient: number, peers: number): bigint {
5781 if(!isWasmInitialized) {
5782 throw new Error("initializeWasm() must be awaited first!");
5784 const nativeResponseValue = wasm.TS_MessageRouter_create_blinded_paths(this_arg, recipient, peers);
5785 return nativeResponseValue;
5788 export interface LDKRouter {
5789 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
5790 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
5791 create_blinded_payment_paths (recipient: number, first_hops: number, tlvs: bigint, amount_msats: bigint): bigint;
5795 export function LDKRouter_new(impl: LDKRouter, MessageRouter: number): [bigint, number] {
5796 if(!isWasmInitialized) {
5797 throw new Error("initializeWasm() must be awaited first!");
5799 var new_obj_idx = js_objs.length;
5800 for (var i = 0; i < js_objs.length; i++) {
5801 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5803 js_objs[i] = new WeakRef(impl);
5804 return [wasm.TS_LDKRouter_new(i, MessageRouter), i];
5806 // 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
5808 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
5809 if(!isWasmInitialized) {
5810 throw new Error("initializeWasm() must be awaited first!");
5812 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
5813 return nativeResponseValue;
5815 // 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
5817 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 {
5818 if(!isWasmInitialized) {
5819 throw new Error("initializeWasm() must be awaited first!");
5821 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
5822 return nativeResponseValue;
5824 // LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ Router_create_blinded_payment_paths LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats
5826 export function Router_create_blinded_payment_paths(this_arg: bigint, recipient: number, first_hops: number, tlvs: bigint, amount_msats: bigint): bigint {
5827 if(!isWasmInitialized) {
5828 throw new Error("initializeWasm() must be awaited first!");
5830 const nativeResponseValue = wasm.TS_Router_create_blinded_payment_paths(this_arg, recipient, first_hops, tlvs, amount_msats);
5831 return nativeResponseValue;
5833 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
5835 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner: bigint): number {
5836 if(!isWasmInitialized) {
5837 throw new Error("initializeWasm() must be awaited first!");
5839 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner);
5840 return nativeResponseValue;
5842 // struct LDKChannelManager C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
5844 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner: bigint): bigint {
5845 if(!isWasmInitialized) {
5846 throw new Error("initializeWasm() must be awaited first!");
5848 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner);
5849 return nativeResponseValue;
5851 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5853 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
5854 if(!isWasmInitialized) {
5855 throw new Error("initializeWasm() must be awaited first!");
5857 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner);
5858 return nativeResponseValue;
5860 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5862 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
5863 if(!isWasmInitialized) {
5864 throw new Error("initializeWasm() must be awaited first!");
5866 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner);
5867 return nativeResponseValue;
5870 export class LDKMaxDustHTLCExposure {
5871 protected constructor() {}
5874 export function LDKMaxDustHTLCExposure_ty_from_ptr(ptr: bigint): number {
5875 if(!isWasmInitialized) {
5876 throw new Error("initializeWasm() must be awaited first!");
5878 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_ty_from_ptr(ptr);
5879 return nativeResponseValue;
5882 export function LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr: bigint): bigint {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr);
5887 return nativeResponseValue;
5890 export function LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr: bigint): bigint {
5891 if(!isWasmInitialized) {
5892 throw new Error("initializeWasm() must be awaited first!");
5894 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr);
5895 return nativeResponseValue;
5897 // struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5899 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner: bigint): bigint {
5900 if(!isWasmInitialized) {
5901 throw new Error("initializeWasm() must be awaited first!");
5903 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner);
5904 return nativeResponseValue;
5906 // struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5908 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner: bigint): bigint {
5909 if(!isWasmInitialized) {
5910 throw new Error("initializeWasm() must be awaited first!");
5912 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner);
5913 return nativeResponseValue;
5915 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5917 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
5918 if(!isWasmInitialized) {
5919 throw new Error("initializeWasm() must be awaited first!");
5921 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
5922 return nativeResponseValue;
5924 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5926 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
5927 if(!isWasmInitialized) {
5928 throw new Error("initializeWasm() must be awaited first!");
5930 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
5931 return nativeResponseValue;
5934 export class LDKCOption_MaxDustHTLCExposureZ {
5935 protected constructor() {}
5938 export function LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr: bigint): number {
5939 if(!isWasmInitialized) {
5940 throw new Error("initializeWasm() must be awaited first!");
5942 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr);
5943 return nativeResponseValue;
5946 export function LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr: bigint): bigint {
5947 if(!isWasmInitialized) {
5948 throw new Error("initializeWasm() must be awaited first!");
5950 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr);
5951 return nativeResponseValue;
5954 export class LDKCOption_APIErrorZ {
5955 protected constructor() {}
5958 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
5959 if(!isWasmInitialized) {
5960 throw new Error("initializeWasm() must be awaited first!");
5962 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
5963 return nativeResponseValue;
5966 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
5967 if(!isWasmInitialized) {
5968 throw new Error("initializeWasm() must be awaited first!");
5970 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
5971 return nativeResponseValue;
5973 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5975 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5976 if(!isWasmInitialized) {
5977 throw new Error("initializeWasm() must be awaited first!");
5979 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
5980 return nativeResponseValue;
5982 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5984 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
5985 if(!isWasmInitialized) {
5986 throw new Error("initializeWasm() must be awaited first!");
5988 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
5989 return nativeResponseValue;
5991 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5993 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5994 if(!isWasmInitialized) {
5995 throw new Error("initializeWasm() must be awaited first!");
5997 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
5998 return nativeResponseValue;
6000 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
6002 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6003 if(!isWasmInitialized) {
6004 throw new Error("initializeWasm() must be awaited first!");
6006 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
6007 return nativeResponseValue;
6010 export class LDKCOption_MonitorEventZ {
6011 protected constructor() {}
6014 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
6015 if(!isWasmInitialized) {
6016 throw new Error("initializeWasm() must be awaited first!");
6018 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
6019 return nativeResponseValue;
6022 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
6023 if(!isWasmInitialized) {
6024 throw new Error("initializeWasm() must be awaited first!");
6026 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
6027 return nativeResponseValue;
6029 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
6031 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
6032 if(!isWasmInitialized) {
6033 throw new Error("initializeWasm() must be awaited first!");
6035 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
6036 return nativeResponseValue;
6038 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
6040 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
6041 if(!isWasmInitialized) {
6042 throw new Error("initializeWasm() must be awaited first!");
6044 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
6045 return nativeResponseValue;
6047 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
6049 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6050 if(!isWasmInitialized) {
6051 throw new Error("initializeWasm() must be awaited first!");
6053 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
6054 return nativeResponseValue;
6056 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
6058 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6059 if(!isWasmInitialized) {
6060 throw new Error("initializeWasm() must be awaited first!");
6062 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
6063 return nativeResponseValue;
6065 // struct LDKOutPoint C2Tuple_OutPointCVec_u8ZZ_get_a(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
6067 export function C2Tuple_OutPointCVec_u8ZZ_get_a(owner: bigint): bigint {
6068 if(!isWasmInitialized) {
6069 throw new Error("initializeWasm() must be awaited first!");
6071 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_a(owner);
6072 return nativeResponseValue;
6074 // struct LDKCVec_u8Z C2Tuple_OutPointCVec_u8ZZ_get_b(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
6076 export function C2Tuple_OutPointCVec_u8ZZ_get_b(owner: bigint): number {
6077 if(!isWasmInitialized) {
6078 throw new Error("initializeWasm() must be awaited first!");
6080 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_b(owner);
6081 return nativeResponseValue;
6083 // uint32_t C2Tuple_u32CVec_u8ZZ_get_a(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
6085 export function C2Tuple_u32CVec_u8ZZ_get_a(owner: bigint): number {
6086 if(!isWasmInitialized) {
6087 throw new Error("initializeWasm() must be awaited first!");
6089 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_a(owner);
6090 return nativeResponseValue;
6092 // struct LDKCVec_u8Z C2Tuple_u32CVec_u8ZZ_get_b(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
6094 export function C2Tuple_u32CVec_u8ZZ_get_b(owner: bigint): number {
6095 if(!isWasmInitialized) {
6096 throw new Error("initializeWasm() must be awaited first!");
6098 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_b(owner);
6099 return nativeResponseValue;
6101 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
6103 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner: bigint): number {
6104 if(!isWasmInitialized) {
6105 throw new Error("initializeWasm() must be awaited first!");
6107 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner);
6108 return nativeResponseValue;
6110 // struct LDKCVec_C2Tuple_u32CVec_u8ZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
6112 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner: bigint): number {
6113 if(!isWasmInitialized) {
6114 throw new Error("initializeWasm() must be awaited first!");
6116 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner);
6117 return nativeResponseValue;
6119 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
6121 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
6122 if(!isWasmInitialized) {
6123 throw new Error("initializeWasm() must be awaited first!");
6125 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
6126 return nativeResponseValue;
6128 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
6130 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
6131 if(!isWasmInitialized) {
6132 throw new Error("initializeWasm() must be awaited first!");
6134 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
6135 return nativeResponseValue;
6137 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
6139 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
6140 if(!isWasmInitialized) {
6141 throw new Error("initializeWasm() must be awaited first!");
6143 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
6144 return nativeResponseValue;
6146 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
6148 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
6149 if(!isWasmInitialized) {
6150 throw new Error("initializeWasm() must be awaited first!");
6152 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
6153 return nativeResponseValue;
6156 export class LDKBalance {
6157 protected constructor() {}
6160 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
6161 if(!isWasmInitialized) {
6162 throw new Error("initializeWasm() must be awaited first!");
6164 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
6165 return nativeResponseValue;
6168 export function LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr: bigint): bigint {
6169 if(!isWasmInitialized) {
6170 throw new Error("initializeWasm() must be awaited first!");
6172 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr);
6173 return nativeResponseValue;
6176 export function LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr: bigint): bigint {
6177 if(!isWasmInitialized) {
6178 throw new Error("initializeWasm() must be awaited first!");
6180 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr);
6181 return nativeResponseValue;
6184 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
6185 if(!isWasmInitialized) {
6186 throw new Error("initializeWasm() must be awaited first!");
6188 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
6189 return nativeResponseValue;
6192 export function LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr: bigint): bigint {
6193 if(!isWasmInitialized) {
6194 throw new Error("initializeWasm() must be awaited first!");
6196 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr);
6197 return nativeResponseValue;
6200 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
6201 if(!isWasmInitialized) {
6202 throw new Error("initializeWasm() must be awaited first!");
6204 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
6205 return nativeResponseValue;
6208 export function LDKBalance_ContentiousClaimable_get_payment_hash(ptr: bigint): number {
6209 if(!isWasmInitialized) {
6210 throw new Error("initializeWasm() must be awaited first!");
6212 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_hash(ptr);
6213 return nativeResponseValue;
6216 export function LDKBalance_ContentiousClaimable_get_payment_preimage(ptr: bigint): number {
6217 if(!isWasmInitialized) {
6218 throw new Error("initializeWasm() must be awaited first!");
6220 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_preimage(ptr);
6221 return nativeResponseValue;
6224 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr);
6229 return nativeResponseValue;
6232 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
6233 if(!isWasmInitialized) {
6234 throw new Error("initializeWasm() must be awaited first!");
6236 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
6237 return nativeResponseValue;
6240 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr: bigint): number {
6241 if(!isWasmInitialized) {
6242 throw new Error("initializeWasm() must be awaited first!");
6244 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr);
6245 return nativeResponseValue;
6248 export function LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
6249 if(!isWasmInitialized) {
6250 throw new Error("initializeWasm() must be awaited first!");
6252 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr);
6253 return nativeResponseValue;
6256 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
6257 if(!isWasmInitialized) {
6258 throw new Error("initializeWasm() must be awaited first!");
6260 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
6261 return nativeResponseValue;
6264 export function LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr: bigint): number {
6265 if(!isWasmInitialized) {
6266 throw new Error("initializeWasm() must be awaited first!");
6268 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr);
6269 return nativeResponseValue;
6272 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr: bigint): bigint {
6273 if(!isWasmInitialized) {
6274 throw new Error("initializeWasm() must be awaited first!");
6276 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr);
6277 return nativeResponseValue;
6279 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
6281 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner: bigint): number {
6282 if(!isWasmInitialized) {
6283 throw new Error("initializeWasm() must be awaited first!");
6285 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner);
6286 return nativeResponseValue;
6288 // struct LDKChannelMonitor C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
6290 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner: bigint): bigint {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner);
6295 return nativeResponseValue;
6297 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
6299 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
6300 if(!isWasmInitialized) {
6301 throw new Error("initializeWasm() must be awaited first!");
6303 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner);
6304 return nativeResponseValue;
6306 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
6308 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
6309 if(!isWasmInitialized) {
6310 throw new Error("initializeWasm() must be awaited first!");
6312 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner);
6313 return nativeResponseValue;
6316 export interface LDKType {
6318 debug_str (): number;
6323 export function LDKType_new(impl: LDKType): [bigint, number] {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 var new_obj_idx = js_objs.length;
6328 for (var i = 0; i < js_objs.length; i++) {
6329 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6331 js_objs[i] = new WeakRef(impl);
6332 return [wasm.TS_LDKType_new(i), i];
6334 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
6336 export function Type_type_id(this_arg: bigint): number {
6337 if(!isWasmInitialized) {
6338 throw new Error("initializeWasm() must be awaited first!");
6340 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
6341 return nativeResponseValue;
6343 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
6345 export function Type_debug_str(this_arg: bigint): number {
6346 if(!isWasmInitialized) {
6347 throw new Error("initializeWasm() must be awaited first!");
6349 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
6350 return nativeResponseValue;
6352 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
6354 export function Type_write(this_arg: bigint): number {
6355 if(!isWasmInitialized) {
6356 throw new Error("initializeWasm() must be awaited first!");
6358 const nativeResponseValue = wasm.TS_Type_write(this_arg);
6359 return nativeResponseValue;
6361 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
6363 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
6364 if(!isWasmInitialized) {
6365 throw new Error("initializeWasm() must be awaited first!");
6367 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
6368 return nativeResponseValue;
6370 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
6372 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
6373 if(!isWasmInitialized) {
6374 throw new Error("initializeWasm() must be awaited first!");
6376 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
6377 return nativeResponseValue;
6379 // struct LDKPublicKey C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR owner);
6381 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(owner: bigint): number {
6382 if(!isWasmInitialized) {
6383 throw new Error("initializeWasm() must be awaited first!");
6385 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(owner);
6386 return nativeResponseValue;
6388 // struct LDKCVec_SocketAddressZ C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR owner);
6390 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(owner: bigint): number {
6391 if(!isWasmInitialized) {
6392 throw new Error("initializeWasm() must be awaited first!");
6394 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(owner);
6395 return nativeResponseValue;
6398 export interface LDKOnionMessageContents {
6399 tlv_type (): bigint;
6401 debug_str (): number;
6405 export function LDKOnionMessageContents_new(impl: LDKOnionMessageContents): [bigint, number] {
6406 if(!isWasmInitialized) {
6407 throw new Error("initializeWasm() must be awaited first!");
6409 var new_obj_idx = js_objs.length;
6410 for (var i = 0; i < js_objs.length; i++) {
6411 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6413 js_objs[i] = new WeakRef(impl);
6414 return [wasm.TS_LDKOnionMessageContents_new(i), i];
6416 // uint64_t OnionMessageContents_tlv_type LDKOnionMessageContents *NONNULL_PTR this_arg
6418 export function OnionMessageContents_tlv_type(this_arg: bigint): bigint {
6419 if(!isWasmInitialized) {
6420 throw new Error("initializeWasm() must be awaited first!");
6422 const nativeResponseValue = wasm.TS_OnionMessageContents_tlv_type(this_arg);
6423 return nativeResponseValue;
6425 // LDKCVec_u8Z OnionMessageContents_write LDKOnionMessageContents *NONNULL_PTR this_arg
6427 export function OnionMessageContents_write(this_arg: bigint): number {
6428 if(!isWasmInitialized) {
6429 throw new Error("initializeWasm() must be awaited first!");
6431 const nativeResponseValue = wasm.TS_OnionMessageContents_write(this_arg);
6432 return nativeResponseValue;
6434 // LDKStr OnionMessageContents_debug_str LDKOnionMessageContents *NONNULL_PTR this_arg
6436 export function OnionMessageContents_debug_str(this_arg: bigint): number {
6437 if(!isWasmInitialized) {
6438 throw new Error("initializeWasm() must be awaited first!");
6440 const nativeResponseValue = wasm.TS_OnionMessageContents_debug_str(this_arg);
6441 return nativeResponseValue;
6444 export class LDKCOption_OnionMessageContentsZ {
6445 protected constructor() {}
6448 export function LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
6449 if(!isWasmInitialized) {
6450 throw new Error("initializeWasm() must be awaited first!");
6452 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr);
6453 return nativeResponseValue;
6456 export function LDKCOption_OnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
6457 if(!isWasmInitialized) {
6458 throw new Error("initializeWasm() must be awaited first!");
6460 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_Some_get_some(ptr);
6461 return nativeResponseValue;
6463 // struct LDKCOption_OnionMessageContentsZ CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
6465 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
6466 if(!isWasmInitialized) {
6467 throw new Error("initializeWasm() must be awaited first!");
6469 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner);
6470 return nativeResponseValue;
6472 // struct LDKDecodeError CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
6474 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
6475 if(!isWasmInitialized) {
6476 throw new Error("initializeWasm() must be awaited first!");
6478 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner);
6479 return nativeResponseValue;
6481 // struct LDKOnionMessageContents C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
6483 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner: bigint): bigint {
6484 if(!isWasmInitialized) {
6485 throw new Error("initializeWasm() must be awaited first!");
6487 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner);
6488 return nativeResponseValue;
6490 // struct LDKDestination C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
6492 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner: bigint): bigint {
6493 if(!isWasmInitialized) {
6494 throw new Error("initializeWasm() must be awaited first!");
6496 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner);
6497 return nativeResponseValue;
6499 // struct LDKBlindedPath C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
6501 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner: bigint): bigint {
6502 if(!isWasmInitialized) {
6503 throw new Error("initializeWasm() must be awaited first!");
6505 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner);
6506 return nativeResponseValue;
6509 export class LDKCOption_TypeZ {
6510 protected constructor() {}
6513 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
6514 if(!isWasmInitialized) {
6515 throw new Error("initializeWasm() must be awaited first!");
6517 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
6518 return nativeResponseValue;
6521 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
6526 return nativeResponseValue;
6528 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6530 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
6535 return nativeResponseValue;
6537 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6539 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
6544 return nativeResponseValue;
6547 export class LDKCOption_SocketAddressZ {
6548 protected constructor() {}
6551 export function LDKCOption_SocketAddressZ_ty_from_ptr(ptr: bigint): number {
6552 if(!isWasmInitialized) {
6553 throw new Error("initializeWasm() must be awaited first!");
6555 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_ty_from_ptr(ptr);
6556 return nativeResponseValue;
6559 export function LDKCOption_SocketAddressZ_Some_get_some(ptr: bigint): bigint {
6560 if(!isWasmInitialized) {
6561 throw new Error("initializeWasm() must be awaited first!");
6563 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_Some_get_some(ptr);
6564 return nativeResponseValue;
6566 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6568 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
6569 if(!isWasmInitialized) {
6570 throw new Error("initializeWasm() must be awaited first!");
6572 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
6573 return nativeResponseValue;
6575 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6577 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
6578 if(!isWasmInitialized) {
6579 throw new Error("initializeWasm() must be awaited first!");
6581 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
6582 return nativeResponseValue;
6584 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6586 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
6587 if(!isWasmInitialized) {
6588 throw new Error("initializeWasm() must be awaited first!");
6590 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
6591 // debug statements here
6593 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6595 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
6596 if(!isWasmInitialized) {
6597 throw new Error("initializeWasm() must be awaited first!");
6599 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
6600 return nativeResponseValue;
6602 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6604 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
6605 if(!isWasmInitialized) {
6606 throw new Error("initializeWasm() must be awaited first!");
6608 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
6609 return nativeResponseValue;
6611 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6613 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
6614 if(!isWasmInitialized) {
6615 throw new Error("initializeWasm() must be awaited first!");
6617 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
6618 return nativeResponseValue;
6621 export class LDKGraphSyncError {
6622 protected constructor() {}
6625 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
6626 if(!isWasmInitialized) {
6627 throw new Error("initializeWasm() must be awaited first!");
6629 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
6630 return nativeResponseValue;
6633 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
6634 if(!isWasmInitialized) {
6635 throw new Error("initializeWasm() must be awaited first!");
6637 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
6638 return nativeResponseValue;
6641 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
6642 if(!isWasmInitialized) {
6643 throw new Error("initializeWasm() must be awaited first!");
6645 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
6646 return nativeResponseValue;
6648 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
6650 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
6651 if(!isWasmInitialized) {
6652 throw new Error("initializeWasm() must be awaited first!");
6654 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
6655 return nativeResponseValue;
6657 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
6659 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
6660 if(!isWasmInitialized) {
6661 throw new Error("initializeWasm() must be awaited first!");
6663 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
6664 return nativeResponseValue;
6666 // struct LDKCVec_u8Z CResult_CVec_u8ZIOErrorZ_get_ok(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
6668 export function CResult_CVec_u8ZIOErrorZ_get_ok(owner: bigint): number {
6669 if(!isWasmInitialized) {
6670 throw new Error("initializeWasm() must be awaited first!");
6672 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_ok(owner);
6673 return nativeResponseValue;
6675 // enum LDKIOError CResult_CVec_u8ZIOErrorZ_get_err(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
6677 export function CResult_CVec_u8ZIOErrorZ_get_err(owner: bigint): IOError {
6678 if(!isWasmInitialized) {
6679 throw new Error("initializeWasm() must be awaited first!");
6681 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_err(owner);
6682 return nativeResponseValue;
6684 // void CResult_NoneIOErrorZ_get_ok(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
6686 export function CResult_NoneIOErrorZ_get_ok(owner: bigint): void {
6687 if(!isWasmInitialized) {
6688 throw new Error("initializeWasm() must be awaited first!");
6690 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_ok(owner);
6691 // debug statements here
6693 // enum LDKIOError CResult_NoneIOErrorZ_get_err(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
6695 export function CResult_NoneIOErrorZ_get_err(owner: bigint): IOError {
6696 if(!isWasmInitialized) {
6697 throw new Error("initializeWasm() must be awaited first!");
6699 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_err(owner);
6700 return nativeResponseValue;
6702 // struct LDKCVec_StrZ CResult_CVec_StrZIOErrorZ_get_ok(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
6704 export function CResult_CVec_StrZIOErrorZ_get_ok(owner: bigint): number {
6705 if(!isWasmInitialized) {
6706 throw new Error("initializeWasm() must be awaited first!");
6708 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_ok(owner);
6709 return nativeResponseValue;
6711 // enum LDKIOError CResult_CVec_StrZIOErrorZ_get_err(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
6713 export function CResult_CVec_StrZIOErrorZ_get_err(owner: bigint): IOError {
6714 if(!isWasmInitialized) {
6715 throw new Error("initializeWasm() must be awaited first!");
6717 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_err(owner);
6718 return nativeResponseValue;
6720 // struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
6722 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner: bigint): number {
6723 if(!isWasmInitialized) {
6724 throw new Error("initializeWasm() must be awaited first!");
6726 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner);
6727 return nativeResponseValue;
6729 // enum LDKIOError CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
6731 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner: bigint): IOError {
6732 if(!isWasmInitialized) {
6733 throw new Error("initializeWasm() must be awaited first!");
6735 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner);
6736 return nativeResponseValue;
6738 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
6740 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner: bigint): bigint {
6741 if(!isWasmInitialized) {
6742 throw new Error("initializeWasm() must be awaited first!");
6744 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner);
6745 return nativeResponseValue;
6747 // enum LDKIOError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
6749 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner: bigint): IOError {
6750 if(!isWasmInitialized) {
6751 throw new Error("initializeWasm() must be awaited first!");
6753 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner);
6754 return nativeResponseValue;
6756 // struct LDKUnsignedInvoiceRequest CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_ok(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR owner);
6758 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
6759 if(!isWasmInitialized) {
6760 throw new Error("initializeWasm() must be awaited first!");
6762 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_ok(owner);
6763 return nativeResponseValue;
6765 // enum LDKBolt12SemanticError CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_err(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR owner);
6767 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
6768 if(!isWasmInitialized) {
6769 throw new Error("initializeWasm() must be awaited first!");
6771 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_get_err(owner);
6772 return nativeResponseValue;
6774 // struct LDKInvoiceRequest CResult_InvoiceRequestBolt12SemanticErrorZ_get_ok(LDKCResult_InvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR owner);
6776 export function CResult_InvoiceRequestBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
6777 if(!isWasmInitialized) {
6778 throw new Error("initializeWasm() must be awaited first!");
6780 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_get_ok(owner);
6781 return nativeResponseValue;
6783 // enum LDKBolt12SemanticError CResult_InvoiceRequestBolt12SemanticErrorZ_get_err(LDKCResult_InvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR owner);
6785 export function CResult_InvoiceRequestBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
6786 if(!isWasmInitialized) {
6787 throw new Error("initializeWasm() must be awaited first!");
6789 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_get_err(owner);
6790 return nativeResponseValue;
6793 export class LDKCOption_SecretKeyZ {
6794 protected constructor() {}
6797 export function LDKCOption_SecretKeyZ_ty_from_ptr(ptr: bigint): number {
6798 if(!isWasmInitialized) {
6799 throw new Error("initializeWasm() must be awaited first!");
6801 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_ty_from_ptr(ptr);
6802 return nativeResponseValue;
6805 export function LDKCOption_SecretKeyZ_Some_get_some(ptr: bigint): number {
6806 if(!isWasmInitialized) {
6807 throw new Error("initializeWasm() must be awaited first!");
6809 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_Some_get_some(ptr);
6810 return nativeResponseValue;
6812 // struct LDKInvoiceWithExplicitSigningPubkeyBuilder CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
6814 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
6815 if(!isWasmInitialized) {
6816 throw new Error("initializeWasm() must be awaited first!");
6818 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(owner);
6819 return nativeResponseValue;
6821 // enum LDKBolt12SemanticError CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
6823 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
6824 if(!isWasmInitialized) {
6825 throw new Error("initializeWasm() must be awaited first!");
6827 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(owner);
6828 return nativeResponseValue;
6830 // struct LDKVerifiedInvoiceRequest CResult_VerifiedInvoiceRequestNoneZ_get_ok(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
6832 export function CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner: bigint): bigint {
6833 if(!isWasmInitialized) {
6834 throw new Error("initializeWasm() must be awaited first!");
6836 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner);
6837 return nativeResponseValue;
6839 // void CResult_VerifiedInvoiceRequestNoneZ_get_err(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
6841 export function CResult_VerifiedInvoiceRequestNoneZ_get_err(owner: bigint): void {
6842 if(!isWasmInitialized) {
6843 throw new Error("initializeWasm() must be awaited first!");
6845 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_err(owner);
6846 // debug statements here
6848 // struct LDKInvoiceWithDerivedSigningPubkeyBuilder CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
6850 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(owner: bigint): bigint {
6851 if(!isWasmInitialized) {
6852 throw new Error("initializeWasm() must be awaited first!");
6854 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_ok(owner);
6855 return nativeResponseValue;
6857 // enum LDKBolt12SemanticError CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR owner);
6859 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
6860 if(!isWasmInitialized) {
6861 throw new Error("initializeWasm() must be awaited first!");
6863 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_get_err(owner);
6864 return nativeResponseValue;
6866 // struct LDKInvoiceRequestFields CResult_InvoiceRequestFieldsDecodeErrorZ_get_ok(LDKCResult_InvoiceRequestFieldsDecodeErrorZ *NONNULL_PTR owner);
6868 export function CResult_InvoiceRequestFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
6869 if(!isWasmInitialized) {
6870 throw new Error("initializeWasm() must be awaited first!");
6872 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_get_ok(owner);
6873 return nativeResponseValue;
6875 // struct LDKDecodeError CResult_InvoiceRequestFieldsDecodeErrorZ_get_err(LDKCResult_InvoiceRequestFieldsDecodeErrorZ *NONNULL_PTR owner);
6877 export function CResult_InvoiceRequestFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
6878 if(!isWasmInitialized) {
6879 throw new Error("initializeWasm() must be awaited first!");
6881 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_get_err(owner);
6882 return nativeResponseValue;
6885 export class LDKCOption_ECDSASignatureZ {
6886 protected constructor() {}
6889 export function LDKCOption_ECDSASignatureZ_ty_from_ptr(ptr: bigint): number {
6890 if(!isWasmInitialized) {
6891 throw new Error("initializeWasm() must be awaited first!");
6893 const nativeResponseValue = wasm.TS_LDKCOption_ECDSASignatureZ_ty_from_ptr(ptr);
6894 return nativeResponseValue;
6897 export function LDKCOption_ECDSASignatureZ_Some_get_some(ptr: bigint): number {
6898 if(!isWasmInitialized) {
6899 throw new Error("initializeWasm() must be awaited first!");
6901 const nativeResponseValue = wasm.TS_LDKCOption_ECDSASignatureZ_Some_get_some(ptr);
6902 return nativeResponseValue;
6905 export class LDKCOption_i64Z {
6906 protected constructor() {}
6909 export function LDKCOption_i64Z_ty_from_ptr(ptr: bigint): number {
6910 if(!isWasmInitialized) {
6911 throw new Error("initializeWasm() must be awaited first!");
6913 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_ty_from_ptr(ptr);
6914 return nativeResponseValue;
6917 export function LDKCOption_i64Z_Some_get_some(ptr: bigint): bigint {
6918 if(!isWasmInitialized) {
6919 throw new Error("initializeWasm() must be awaited first!");
6921 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_Some_get_some(ptr);
6922 return nativeResponseValue;
6924 // struct LDKSocketAddress CResult_SocketAddressDecodeErrorZ_get_ok(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
6926 export function CResult_SocketAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
6927 if(!isWasmInitialized) {
6928 throw new Error("initializeWasm() must be awaited first!");
6930 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_ok(owner);
6931 return nativeResponseValue;
6933 // struct LDKDecodeError CResult_SocketAddressDecodeErrorZ_get_err(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
6935 export function CResult_SocketAddressDecodeErrorZ_get_err(owner: bigint): bigint {
6936 if(!isWasmInitialized) {
6937 throw new Error("initializeWasm() must be awaited first!");
6939 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_err(owner);
6940 return nativeResponseValue;
6942 // struct LDKSocketAddress CResult_SocketAddressSocketAddressParseErrorZ_get_ok(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
6944 export function CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner: bigint): bigint {
6945 if(!isWasmInitialized) {
6946 throw new Error("initializeWasm() must be awaited first!");
6948 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner);
6949 return nativeResponseValue;
6951 // enum LDKSocketAddressParseError CResult_SocketAddressSocketAddressParseErrorZ_get_err(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
6953 export function CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner: bigint): SocketAddressParseError {
6954 if(!isWasmInitialized) {
6955 throw new Error("initializeWasm() must be awaited first!");
6957 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner);
6958 return nativeResponseValue;
6960 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6962 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6963 if(!isWasmInitialized) {
6964 throw new Error("initializeWasm() must be awaited first!");
6966 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
6967 return nativeResponseValue;
6969 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6971 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6972 if(!isWasmInitialized) {
6973 throw new Error("initializeWasm() must be awaited first!");
6975 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
6976 return nativeResponseValue;
6978 // struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6980 export function CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6981 if(!isWasmInitialized) {
6982 throw new Error("initializeWasm() must be awaited first!");
6984 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner);
6985 return nativeResponseValue;
6987 // struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6989 export function CResult_AcceptChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6990 if(!isWasmInitialized) {
6991 throw new Error("initializeWasm() must be awaited first!");
6993 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(owner);
6994 return nativeResponseValue;
6996 // struct LDKStfu CResult_StfuDecodeErrorZ_get_ok(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR owner);
6998 export function CResult_StfuDecodeErrorZ_get_ok(owner: bigint): bigint {
6999 if(!isWasmInitialized) {
7000 throw new Error("initializeWasm() must be awaited first!");
7002 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_get_ok(owner);
7003 return nativeResponseValue;
7005 // struct LDKDecodeError CResult_StfuDecodeErrorZ_get_err(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR owner);
7007 export function CResult_StfuDecodeErrorZ_get_err(owner: bigint): bigint {
7008 if(!isWasmInitialized) {
7009 throw new Error("initializeWasm() must be awaited first!");
7011 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_get_err(owner);
7012 return nativeResponseValue;
7014 // struct LDKSplice CResult_SpliceDecodeErrorZ_get_ok(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR owner);
7016 export function CResult_SpliceDecodeErrorZ_get_ok(owner: bigint): bigint {
7017 if(!isWasmInitialized) {
7018 throw new Error("initializeWasm() must be awaited first!");
7020 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_get_ok(owner);
7021 return nativeResponseValue;
7023 // struct LDKDecodeError CResult_SpliceDecodeErrorZ_get_err(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR owner);
7025 export function CResult_SpliceDecodeErrorZ_get_err(owner: bigint): bigint {
7026 if(!isWasmInitialized) {
7027 throw new Error("initializeWasm() must be awaited first!");
7029 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_get_err(owner);
7030 return nativeResponseValue;
7032 // struct LDKSpliceAck CResult_SpliceAckDecodeErrorZ_get_ok(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR owner);
7034 export function CResult_SpliceAckDecodeErrorZ_get_ok(owner: bigint): bigint {
7035 if(!isWasmInitialized) {
7036 throw new Error("initializeWasm() must be awaited first!");
7038 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_get_ok(owner);
7039 return nativeResponseValue;
7041 // struct LDKDecodeError CResult_SpliceAckDecodeErrorZ_get_err(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR owner);
7043 export function CResult_SpliceAckDecodeErrorZ_get_err(owner: bigint): bigint {
7044 if(!isWasmInitialized) {
7045 throw new Error("initializeWasm() must be awaited first!");
7047 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_get_err(owner);
7048 return nativeResponseValue;
7050 // struct LDKSpliceLocked CResult_SpliceLockedDecodeErrorZ_get_ok(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR owner);
7052 export function CResult_SpliceLockedDecodeErrorZ_get_ok(owner: bigint): bigint {
7053 if(!isWasmInitialized) {
7054 throw new Error("initializeWasm() must be awaited first!");
7056 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_get_ok(owner);
7057 return nativeResponseValue;
7059 // struct LDKDecodeError CResult_SpliceLockedDecodeErrorZ_get_err(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR owner);
7061 export function CResult_SpliceLockedDecodeErrorZ_get_err(owner: bigint): bigint {
7062 if(!isWasmInitialized) {
7063 throw new Error("initializeWasm() must be awaited first!");
7065 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_get_err(owner);
7066 return nativeResponseValue;
7068 // struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
7070 export function CResult_TxAddInputDecodeErrorZ_get_ok(owner: bigint): bigint {
7071 if(!isWasmInitialized) {
7072 throw new Error("initializeWasm() must be awaited first!");
7074 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_ok(owner);
7075 return nativeResponseValue;
7077 // struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
7079 export function CResult_TxAddInputDecodeErrorZ_get_err(owner: bigint): bigint {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_err(owner);
7084 return nativeResponseValue;
7086 // struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
7088 export function CResult_TxAddOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
7089 if(!isWasmInitialized) {
7090 throw new Error("initializeWasm() must be awaited first!");
7092 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_ok(owner);
7093 return nativeResponseValue;
7095 // struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
7097 export function CResult_TxAddOutputDecodeErrorZ_get_err(owner: bigint): bigint {
7098 if(!isWasmInitialized) {
7099 throw new Error("initializeWasm() must be awaited first!");
7101 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_err(owner);
7102 return nativeResponseValue;
7104 // struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
7106 export function CResult_TxRemoveInputDecodeErrorZ_get_ok(owner: bigint): bigint {
7107 if(!isWasmInitialized) {
7108 throw new Error("initializeWasm() must be awaited first!");
7110 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(owner);
7111 return nativeResponseValue;
7113 // struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
7115 export function CResult_TxRemoveInputDecodeErrorZ_get_err(owner: bigint): bigint {
7116 if(!isWasmInitialized) {
7117 throw new Error("initializeWasm() must be awaited first!");
7119 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_err(owner);
7120 return nativeResponseValue;
7122 // struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
7124 export function CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
7125 if(!isWasmInitialized) {
7126 throw new Error("initializeWasm() must be awaited first!");
7128 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner);
7129 return nativeResponseValue;
7131 // struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
7133 export function CResult_TxRemoveOutputDecodeErrorZ_get_err(owner: bigint): bigint {
7134 if(!isWasmInitialized) {
7135 throw new Error("initializeWasm() must be awaited first!");
7137 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(owner);
7138 return nativeResponseValue;
7140 // struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
7142 export function CResult_TxCompleteDecodeErrorZ_get_ok(owner: bigint): bigint {
7143 if(!isWasmInitialized) {
7144 throw new Error("initializeWasm() must be awaited first!");
7146 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_ok(owner);
7147 return nativeResponseValue;
7149 // struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
7151 export function CResult_TxCompleteDecodeErrorZ_get_err(owner: bigint): bigint {
7152 if(!isWasmInitialized) {
7153 throw new Error("initializeWasm() must be awaited first!");
7155 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_err(owner);
7156 return nativeResponseValue;
7158 // struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
7160 export function CResult_TxSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_ok(owner);
7165 return nativeResponseValue;
7167 // struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
7169 export function CResult_TxSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
7170 if(!isWasmInitialized) {
7171 throw new Error("initializeWasm() must be awaited first!");
7173 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_err(owner);
7174 return nativeResponseValue;
7176 // struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
7178 export function CResult_TxInitRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
7179 if(!isWasmInitialized) {
7180 throw new Error("initializeWasm() must be awaited first!");
7182 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_ok(owner);
7183 return nativeResponseValue;
7185 // struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
7187 export function CResult_TxInitRbfDecodeErrorZ_get_err(owner: bigint): bigint {
7188 if(!isWasmInitialized) {
7189 throw new Error("initializeWasm() must be awaited first!");
7191 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_err(owner);
7192 return nativeResponseValue;
7194 // struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
7196 export function CResult_TxAckRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
7197 if(!isWasmInitialized) {
7198 throw new Error("initializeWasm() must be awaited first!");
7200 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_ok(owner);
7201 return nativeResponseValue;
7203 // struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
7205 export function CResult_TxAckRbfDecodeErrorZ_get_err(owner: bigint): bigint {
7206 if(!isWasmInitialized) {
7207 throw new Error("initializeWasm() must be awaited first!");
7209 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_err(owner);
7210 return nativeResponseValue;
7212 // struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
7214 export function CResult_TxAbortDecodeErrorZ_get_ok(owner: bigint): bigint {
7215 if(!isWasmInitialized) {
7216 throw new Error("initializeWasm() must be awaited first!");
7218 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_ok(owner);
7219 return nativeResponseValue;
7221 // struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
7223 export function CResult_TxAbortDecodeErrorZ_get_err(owner: bigint): bigint {
7224 if(!isWasmInitialized) {
7225 throw new Error("initializeWasm() must be awaited first!");
7227 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_err(owner);
7228 return nativeResponseValue;
7230 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
7232 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
7233 if(!isWasmInitialized) {
7234 throw new Error("initializeWasm() must be awaited first!");
7236 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
7237 return nativeResponseValue;
7239 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
7241 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
7242 if(!isWasmInitialized) {
7243 throw new Error("initializeWasm() must be awaited first!");
7245 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
7246 return nativeResponseValue;
7248 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
7250 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
7251 if(!isWasmInitialized) {
7252 throw new Error("initializeWasm() must be awaited first!");
7254 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
7255 return nativeResponseValue;
7257 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
7259 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
7260 if(!isWasmInitialized) {
7261 throw new Error("initializeWasm() must be awaited first!");
7263 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
7264 return nativeResponseValue;
7266 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
7268 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7269 if(!isWasmInitialized) {
7270 throw new Error("initializeWasm() must be awaited first!");
7272 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
7273 return nativeResponseValue;
7275 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
7277 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7278 if(!isWasmInitialized) {
7279 throw new Error("initializeWasm() must be awaited first!");
7281 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
7282 return nativeResponseValue;
7284 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
7286 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7287 if(!isWasmInitialized) {
7288 throw new Error("initializeWasm() must be awaited first!");
7290 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
7291 return nativeResponseValue;
7293 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
7295 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7296 if(!isWasmInitialized) {
7297 throw new Error("initializeWasm() must be awaited first!");
7299 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
7300 return nativeResponseValue;
7302 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
7304 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7305 if(!isWasmInitialized) {
7306 throw new Error("initializeWasm() must be awaited first!");
7308 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
7309 return nativeResponseValue;
7311 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
7313 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7314 if(!isWasmInitialized) {
7315 throw new Error("initializeWasm() must be awaited first!");
7317 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
7318 return nativeResponseValue;
7320 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
7322 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
7323 if(!isWasmInitialized) {
7324 throw new Error("initializeWasm() must be awaited first!");
7326 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
7327 return nativeResponseValue;
7329 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
7331 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
7332 if(!isWasmInitialized) {
7333 throw new Error("initializeWasm() must be awaited first!");
7335 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
7336 return nativeResponseValue;
7338 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
7340 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7341 if(!isWasmInitialized) {
7342 throw new Error("initializeWasm() must be awaited first!");
7344 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
7345 return nativeResponseValue;
7347 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
7349 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7350 if(!isWasmInitialized) {
7351 throw new Error("initializeWasm() must be awaited first!");
7353 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
7354 return nativeResponseValue;
7356 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
7358 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
7359 if(!isWasmInitialized) {
7360 throw new Error("initializeWasm() must be awaited first!");
7362 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
7363 return nativeResponseValue;
7365 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
7367 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
7368 if(!isWasmInitialized) {
7369 throw new Error("initializeWasm() must be awaited first!");
7371 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
7372 return nativeResponseValue;
7374 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
7376 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
7377 if(!isWasmInitialized) {
7378 throw new Error("initializeWasm() must be awaited first!");
7380 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
7381 return nativeResponseValue;
7383 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
7385 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
7390 return nativeResponseValue;
7392 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
7394 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
7399 return nativeResponseValue;
7401 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
7403 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
7408 return nativeResponseValue;
7410 // struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
7412 export function CResult_OpenChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(owner);
7417 return nativeResponseValue;
7419 // struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
7421 export function CResult_OpenChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_err(owner);
7426 return nativeResponseValue;
7428 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
7430 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
7431 if(!isWasmInitialized) {
7432 throw new Error("initializeWasm() must be awaited first!");
7434 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
7435 return nativeResponseValue;
7437 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
7439 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
7440 if(!isWasmInitialized) {
7441 throw new Error("initializeWasm() must be awaited first!");
7443 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
7444 return nativeResponseValue;
7446 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
7448 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
7449 if(!isWasmInitialized) {
7450 throw new Error("initializeWasm() must be awaited first!");
7452 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
7453 return nativeResponseValue;
7455 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
7457 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
7458 if(!isWasmInitialized) {
7459 throw new Error("initializeWasm() must be awaited first!");
7461 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
7462 return nativeResponseValue;
7464 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
7466 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7467 if(!isWasmInitialized) {
7468 throw new Error("initializeWasm() must be awaited first!");
7470 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
7471 return nativeResponseValue;
7473 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
7475 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7476 if(!isWasmInitialized) {
7477 throw new Error("initializeWasm() must be awaited first!");
7479 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
7480 return nativeResponseValue;
7482 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
7484 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7485 if(!isWasmInitialized) {
7486 throw new Error("initializeWasm() must be awaited first!");
7488 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
7489 return nativeResponseValue;
7491 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
7493 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
7498 return nativeResponseValue;
7500 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
7502 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
7503 if(!isWasmInitialized) {
7504 throw new Error("initializeWasm() must be awaited first!");
7506 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
7507 return nativeResponseValue;
7509 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
7511 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
7512 if(!isWasmInitialized) {
7513 throw new Error("initializeWasm() must be awaited first!");
7515 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
7516 return nativeResponseValue;
7518 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
7520 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7521 if(!isWasmInitialized) {
7522 throw new Error("initializeWasm() must be awaited first!");
7524 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
7525 return nativeResponseValue;
7527 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
7529 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7530 if(!isWasmInitialized) {
7531 throw new Error("initializeWasm() must be awaited first!");
7533 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
7534 return nativeResponseValue;
7536 // struct LDKOnionPacket CResult_OnionPacketDecodeErrorZ_get_ok(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR owner);
7538 export function CResult_OnionPacketDecodeErrorZ_get_ok(owner: bigint): bigint {
7539 if(!isWasmInitialized) {
7540 throw new Error("initializeWasm() must be awaited first!");
7542 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_get_ok(owner);
7543 return nativeResponseValue;
7545 // struct LDKDecodeError CResult_OnionPacketDecodeErrorZ_get_err(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR owner);
7547 export function CResult_OnionPacketDecodeErrorZ_get_err(owner: bigint): bigint {
7548 if(!isWasmInitialized) {
7549 throw new Error("initializeWasm() must be awaited first!");
7551 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_get_err(owner);
7552 return nativeResponseValue;
7554 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
7556 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7557 if(!isWasmInitialized) {
7558 throw new Error("initializeWasm() must be awaited first!");
7560 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
7561 return nativeResponseValue;
7563 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
7565 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
7570 return nativeResponseValue;
7572 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
7574 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7575 if(!isWasmInitialized) {
7576 throw new Error("initializeWasm() must be awaited first!");
7578 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
7579 return nativeResponseValue;
7581 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
7583 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7584 if(!isWasmInitialized) {
7585 throw new Error("initializeWasm() must be awaited first!");
7587 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
7588 return nativeResponseValue;
7590 // struct LDKFinalOnionHopData CResult_FinalOnionHopDataDecodeErrorZ_get_ok(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR owner);
7592 export function CResult_FinalOnionHopDataDecodeErrorZ_get_ok(owner: bigint): bigint {
7593 if(!isWasmInitialized) {
7594 throw new Error("initializeWasm() must be awaited first!");
7596 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_get_ok(owner);
7597 return nativeResponseValue;
7599 // struct LDKDecodeError CResult_FinalOnionHopDataDecodeErrorZ_get_err(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR owner);
7601 export function CResult_FinalOnionHopDataDecodeErrorZ_get_err(owner: bigint): bigint {
7602 if(!isWasmInitialized) {
7603 throw new Error("initializeWasm() must be awaited first!");
7605 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_get_err(owner);
7606 return nativeResponseValue;
7608 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7610 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
7611 if(!isWasmInitialized) {
7612 throw new Error("initializeWasm() must be awaited first!");
7614 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
7615 return nativeResponseValue;
7617 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7619 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
7620 if(!isWasmInitialized) {
7621 throw new Error("initializeWasm() must be awaited first!");
7623 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
7624 return nativeResponseValue;
7626 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7628 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
7629 if(!isWasmInitialized) {
7630 throw new Error("initializeWasm() must be awaited first!");
7632 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
7633 return nativeResponseValue;
7635 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7637 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
7642 return nativeResponseValue;
7644 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7646 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7647 if(!isWasmInitialized) {
7648 throw new Error("initializeWasm() must be awaited first!");
7650 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
7651 return nativeResponseValue;
7653 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7655 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7656 if(!isWasmInitialized) {
7657 throw new Error("initializeWasm() must be awaited first!");
7659 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
7660 return nativeResponseValue;
7662 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7664 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7665 if(!isWasmInitialized) {
7666 throw new Error("initializeWasm() must be awaited first!");
7668 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
7669 return nativeResponseValue;
7671 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7673 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7674 if(!isWasmInitialized) {
7675 throw new Error("initializeWasm() must be awaited first!");
7677 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
7678 return nativeResponseValue;
7680 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7682 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7683 if(!isWasmInitialized) {
7684 throw new Error("initializeWasm() must be awaited first!");
7686 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
7687 return nativeResponseValue;
7689 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7691 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7692 if(!isWasmInitialized) {
7693 throw new Error("initializeWasm() must be awaited first!");
7695 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
7696 return nativeResponseValue;
7698 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7700 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7701 if(!isWasmInitialized) {
7702 throw new Error("initializeWasm() must be awaited first!");
7704 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
7705 return nativeResponseValue;
7707 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7709 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7710 if(!isWasmInitialized) {
7711 throw new Error("initializeWasm() must be awaited first!");
7713 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
7714 return nativeResponseValue;
7716 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7718 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7719 if(!isWasmInitialized) {
7720 throw new Error("initializeWasm() must be awaited first!");
7722 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
7723 return nativeResponseValue;
7725 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7727 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7728 if(!isWasmInitialized) {
7729 throw new Error("initializeWasm() must be awaited first!");
7731 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
7732 return nativeResponseValue;
7734 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7736 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7737 if(!isWasmInitialized) {
7738 throw new Error("initializeWasm() must be awaited first!");
7740 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
7741 return nativeResponseValue;
7743 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7745 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7746 if(!isWasmInitialized) {
7747 throw new Error("initializeWasm() must be awaited first!");
7749 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
7750 return nativeResponseValue;
7752 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7754 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7755 if(!isWasmInitialized) {
7756 throw new Error("initializeWasm() must be awaited first!");
7758 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
7759 return nativeResponseValue;
7761 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7763 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7764 if(!isWasmInitialized) {
7765 throw new Error("initializeWasm() must be awaited first!");
7767 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
7768 return nativeResponseValue;
7770 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7772 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7773 if(!isWasmInitialized) {
7774 throw new Error("initializeWasm() must be awaited first!");
7776 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
7777 return nativeResponseValue;
7779 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7781 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
7786 return nativeResponseValue;
7788 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7790 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
7791 if(!isWasmInitialized) {
7792 throw new Error("initializeWasm() must be awaited first!");
7794 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
7795 return nativeResponseValue;
7797 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7799 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
7800 if(!isWasmInitialized) {
7801 throw new Error("initializeWasm() must be awaited first!");
7803 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
7804 return nativeResponseValue;
7806 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7808 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
7809 if(!isWasmInitialized) {
7810 throw new Error("initializeWasm() must be awaited first!");
7812 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
7813 return nativeResponseValue;
7815 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7817 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
7818 if(!isWasmInitialized) {
7819 throw new Error("initializeWasm() must be awaited first!");
7821 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
7822 return nativeResponseValue;
7824 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7826 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7827 if(!isWasmInitialized) {
7828 throw new Error("initializeWasm() must be awaited first!");
7830 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
7831 return nativeResponseValue;
7833 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7835 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7836 if(!isWasmInitialized) {
7837 throw new Error("initializeWasm() must be awaited first!");
7839 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
7840 return nativeResponseValue;
7842 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7844 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7845 if(!isWasmInitialized) {
7846 throw new Error("initializeWasm() must be awaited first!");
7848 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
7849 return nativeResponseValue;
7851 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7853 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7854 if(!isWasmInitialized) {
7855 throw new Error("initializeWasm() must be awaited first!");
7857 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
7858 return nativeResponseValue;
7860 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
7862 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
7863 if(!isWasmInitialized) {
7864 throw new Error("initializeWasm() must be awaited first!");
7866 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
7867 return nativeResponseValue;
7869 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
7871 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
7872 if(!isWasmInitialized) {
7873 throw new Error("initializeWasm() must be awaited first!");
7875 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
7876 return nativeResponseValue;
7879 export class LDKSignOrCreationError {
7880 protected constructor() {}
7883 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
7884 if(!isWasmInitialized) {
7885 throw new Error("initializeWasm() must be awaited first!");
7887 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
7888 return nativeResponseValue;
7891 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
7896 return nativeResponseValue;
7898 // struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
7900 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner);
7905 return nativeResponseValue;
7907 // struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
7909 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
7914 return nativeResponseValue;
7916 // struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
7918 export function CResult_OffersMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_ok(owner);
7923 return nativeResponseValue;
7925 // struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
7927 export function CResult_OffersMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_err(owner);
7932 return nativeResponseValue;
7935 export class LDKCOption_HTLCClaimZ {
7936 protected constructor() {}
7939 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
7940 if(!isWasmInitialized) {
7941 throw new Error("initializeWasm() must be awaited first!");
7943 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
7944 return nativeResponseValue;
7947 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
7948 if(!isWasmInitialized) {
7949 throw new Error("initializeWasm() must be awaited first!");
7951 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
7952 return nativeResponseValue;
7954 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
7956 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
7957 if(!isWasmInitialized) {
7958 throw new Error("initializeWasm() must be awaited first!");
7960 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
7961 return nativeResponseValue;
7963 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
7965 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
7966 if(!isWasmInitialized) {
7967 throw new Error("initializeWasm() must be awaited first!");
7969 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
7970 return nativeResponseValue;
7972 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
7974 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
7975 if(!isWasmInitialized) {
7976 throw new Error("initializeWasm() must be awaited first!");
7978 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
7979 return nativeResponseValue;
7981 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
7983 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
7984 if(!isWasmInitialized) {
7985 throw new Error("initializeWasm() must be awaited first!");
7987 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
7988 return nativeResponseValue;
7990 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
7992 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
7993 if(!isWasmInitialized) {
7994 throw new Error("initializeWasm() must be awaited first!");
7996 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
7997 return nativeResponseValue;
7999 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
8001 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
8002 if(!isWasmInitialized) {
8003 throw new Error("initializeWasm() must be awaited first!");
8005 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
8006 return nativeResponseValue;
8008 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
8010 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
8011 if(!isWasmInitialized) {
8012 throw new Error("initializeWasm() must be awaited first!");
8014 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
8015 return nativeResponseValue;
8017 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
8019 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
8020 if(!isWasmInitialized) {
8021 throw new Error("initializeWasm() must be awaited first!");
8023 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
8024 return nativeResponseValue;
8026 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
8028 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
8029 if(!isWasmInitialized) {
8030 throw new Error("initializeWasm() must be awaited first!");
8032 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
8033 return nativeResponseValue;
8035 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
8037 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
8038 if(!isWasmInitialized) {
8039 throw new Error("initializeWasm() must be awaited first!");
8041 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
8042 return nativeResponseValue;
8044 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
8046 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
8047 if(!isWasmInitialized) {
8048 throw new Error("initializeWasm() must be awaited first!");
8050 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
8051 return nativeResponseValue;
8053 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
8055 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
8056 if(!isWasmInitialized) {
8057 throw new Error("initializeWasm() must be awaited first!");
8059 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
8060 return nativeResponseValue;
8062 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8064 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
8065 if(!isWasmInitialized) {
8066 throw new Error("initializeWasm() must be awaited first!");
8068 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
8069 return nativeResponseValue;
8071 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8073 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
8074 if(!isWasmInitialized) {
8075 throw new Error("initializeWasm() must be awaited first!");
8077 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
8078 return nativeResponseValue;
8080 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8082 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
8083 if(!isWasmInitialized) {
8084 throw new Error("initializeWasm() must be awaited first!");
8086 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
8087 return nativeResponseValue;
8089 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8091 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
8092 if(!isWasmInitialized) {
8093 throw new Error("initializeWasm() must be awaited first!");
8095 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
8096 return nativeResponseValue;
8098 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
8100 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
8101 if(!isWasmInitialized) {
8102 throw new Error("initializeWasm() must be awaited first!");
8104 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
8105 return nativeResponseValue;
8107 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
8109 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
8110 if(!isWasmInitialized) {
8111 throw new Error("initializeWasm() must be awaited first!");
8113 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
8114 // debug statements here
8116 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8118 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
8119 if(!isWasmInitialized) {
8120 throw new Error("initializeWasm() must be awaited first!");
8122 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
8123 return nativeResponseValue;
8125 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
8127 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
8128 if(!isWasmInitialized) {
8129 throw new Error("initializeWasm() must be awaited first!");
8131 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
8132 return nativeResponseValue;
8134 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
8136 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
8137 if(!isWasmInitialized) {
8138 throw new Error("initializeWasm() must be awaited first!");
8140 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
8141 return nativeResponseValue;
8143 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
8145 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
8146 if(!isWasmInitialized) {
8147 throw new Error("initializeWasm() must be awaited first!");
8149 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
8150 // debug statements here
8152 // struct LDKCVec_ECDSASignatureZ CResult_CVec_ECDSASignatureZNoneZ_get_ok(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
8154 export function CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner: bigint): number {
8155 if(!isWasmInitialized) {
8156 throw new Error("initializeWasm() must be awaited first!");
8158 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner);
8159 return nativeResponseValue;
8161 // void CResult_CVec_ECDSASignatureZNoneZ_get_err(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
8163 export function CResult_CVec_ECDSASignatureZNoneZ_get_err(owner: bigint): void {
8164 if(!isWasmInitialized) {
8165 throw new Error("initializeWasm() must be awaited first!");
8167 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_err(owner);
8168 // debug statements here
8171 export class LDKCOption_usizeZ {
8172 protected constructor() {}
8175 export function LDKCOption_usizeZ_ty_from_ptr(ptr: bigint): number {
8176 if(!isWasmInitialized) {
8177 throw new Error("initializeWasm() must be awaited first!");
8179 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_ty_from_ptr(ptr);
8180 return nativeResponseValue;
8183 export function LDKCOption_usizeZ_Some_get_some(ptr: bigint): number {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_Some_get_some(ptr);
8188 return nativeResponseValue;
8190 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
8192 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
8193 if(!isWasmInitialized) {
8194 throw new Error("initializeWasm() must be awaited first!");
8196 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
8197 return nativeResponseValue;
8199 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
8201 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
8202 if(!isWasmInitialized) {
8203 throw new Error("initializeWasm() must be awaited first!");
8205 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
8206 return nativeResponseValue;
8208 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
8210 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
8211 if(!isWasmInitialized) {
8212 throw new Error("initializeWasm() must be awaited first!");
8214 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
8215 return nativeResponseValue;
8217 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
8219 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
8220 if(!isWasmInitialized) {
8221 throw new Error("initializeWasm() must be awaited first!");
8223 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
8224 return nativeResponseValue;
8227 export class LDKPaymentPurpose {
8228 protected constructor() {}
8231 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
8232 if(!isWasmInitialized) {
8233 throw new Error("initializeWasm() must be awaited first!");
8235 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
8236 return nativeResponseValue;
8239 export function LDKPaymentPurpose_Bolt11InvoicePayment_get_payment_preimage(ptr: bigint): bigint {
8240 if(!isWasmInitialized) {
8241 throw new Error("initializeWasm() must be awaited first!");
8243 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt11InvoicePayment_get_payment_preimage(ptr);
8244 return nativeResponseValue;
8247 export function LDKPaymentPurpose_Bolt11InvoicePayment_get_payment_secret(ptr: bigint): number {
8248 if(!isWasmInitialized) {
8249 throw new Error("initializeWasm() must be awaited first!");
8251 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt11InvoicePayment_get_payment_secret(ptr);
8252 return nativeResponseValue;
8255 export function LDKPaymentPurpose_Bolt12OfferPayment_get_payment_preimage(ptr: bigint): bigint {
8256 if(!isWasmInitialized) {
8257 throw new Error("initializeWasm() must be awaited first!");
8259 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12OfferPayment_get_payment_preimage(ptr);
8260 return nativeResponseValue;
8263 export function LDKPaymentPurpose_Bolt12OfferPayment_get_payment_secret(ptr: bigint): number {
8264 if(!isWasmInitialized) {
8265 throw new Error("initializeWasm() must be awaited first!");
8267 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12OfferPayment_get_payment_secret(ptr);
8268 return nativeResponseValue;
8271 export function LDKPaymentPurpose_Bolt12OfferPayment_get_payment_context(ptr: bigint): bigint {
8272 if(!isWasmInitialized) {
8273 throw new Error("initializeWasm() must be awaited first!");
8275 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12OfferPayment_get_payment_context(ptr);
8276 return nativeResponseValue;
8279 export function LDKPaymentPurpose_Bolt12RefundPayment_get_payment_preimage(ptr: bigint): bigint {
8280 if(!isWasmInitialized) {
8281 throw new Error("initializeWasm() must be awaited first!");
8283 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12RefundPayment_get_payment_preimage(ptr);
8284 return nativeResponseValue;
8287 export function LDKPaymentPurpose_Bolt12RefundPayment_get_payment_secret(ptr: bigint): number {
8288 if(!isWasmInitialized) {
8289 throw new Error("initializeWasm() must be awaited first!");
8291 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12RefundPayment_get_payment_secret(ptr);
8292 return nativeResponseValue;
8295 export function LDKPaymentPurpose_Bolt12RefundPayment_get_payment_context(ptr: bigint): bigint {
8296 if(!isWasmInitialized) {
8297 throw new Error("initializeWasm() must be awaited first!");
8299 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_Bolt12RefundPayment_get_payment_context(ptr);
8300 return nativeResponseValue;
8303 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
8304 if(!isWasmInitialized) {
8305 throw new Error("initializeWasm() must be awaited first!");
8307 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
8308 return nativeResponseValue;
8310 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
8312 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
8313 if(!isWasmInitialized) {
8314 throw new Error("initializeWasm() must be awaited first!");
8316 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
8317 return nativeResponseValue;
8319 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
8321 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
8322 if(!isWasmInitialized) {
8323 throw new Error("initializeWasm() must be awaited first!");
8325 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
8326 return nativeResponseValue;
8328 // struct LDKClaimedHTLC CResult_ClaimedHTLCDecodeErrorZ_get_ok(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
8330 export function CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
8331 if(!isWasmInitialized) {
8332 throw new Error("initializeWasm() must be awaited first!");
8334 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner);
8335 return nativeResponseValue;
8337 // struct LDKDecodeError CResult_ClaimedHTLCDecodeErrorZ_get_err(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
8339 export function CResult_ClaimedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
8340 if(!isWasmInitialized) {
8341 throw new Error("initializeWasm() must be awaited first!");
8343 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_err(owner);
8344 return nativeResponseValue;
8347 export class LDKPathFailure {
8348 protected constructor() {}
8351 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
8356 return nativeResponseValue;
8359 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
8360 if(!isWasmInitialized) {
8361 throw new Error("initializeWasm() must be awaited first!");
8363 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
8364 return nativeResponseValue;
8367 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
8368 if(!isWasmInitialized) {
8369 throw new Error("initializeWasm() must be awaited first!");
8371 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
8372 return nativeResponseValue;
8375 export class LDKCOption_PathFailureZ {
8376 protected constructor() {}
8379 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
8380 if(!isWasmInitialized) {
8381 throw new Error("initializeWasm() must be awaited first!");
8383 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
8384 return nativeResponseValue;
8387 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
8388 if(!isWasmInitialized) {
8389 throw new Error("initializeWasm() must be awaited first!");
8391 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
8392 return nativeResponseValue;
8394 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
8396 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
8397 if(!isWasmInitialized) {
8398 throw new Error("initializeWasm() must be awaited first!");
8400 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
8401 return nativeResponseValue;
8403 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
8405 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
8406 if(!isWasmInitialized) {
8407 throw new Error("initializeWasm() must be awaited first!");
8409 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
8410 return nativeResponseValue;
8413 export class LDKCOption_ClosureReasonZ {
8414 protected constructor() {}
8417 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
8418 if(!isWasmInitialized) {
8419 throw new Error("initializeWasm() must be awaited first!");
8421 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
8422 return nativeResponseValue;
8425 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
8426 if(!isWasmInitialized) {
8427 throw new Error("initializeWasm() must be awaited first!");
8429 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
8430 return nativeResponseValue;
8432 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
8434 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
8435 if(!isWasmInitialized) {
8436 throw new Error("initializeWasm() must be awaited first!");
8438 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
8439 return nativeResponseValue;
8441 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
8443 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
8444 if(!isWasmInitialized) {
8445 throw new Error("initializeWasm() must be awaited first!");
8447 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
8448 return nativeResponseValue;
8451 export class LDKHTLCDestination {
8452 protected constructor() {}
8455 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
8456 if(!isWasmInitialized) {
8457 throw new Error("initializeWasm() must be awaited first!");
8459 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
8460 return nativeResponseValue;
8463 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
8464 if(!isWasmInitialized) {
8465 throw new Error("initializeWasm() must be awaited first!");
8467 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
8468 return nativeResponseValue;
8471 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): bigint {
8472 if(!isWasmInitialized) {
8473 throw new Error("initializeWasm() must be awaited first!");
8475 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
8476 return nativeResponseValue;
8479 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
8480 if(!isWasmInitialized) {
8481 throw new Error("initializeWasm() must be awaited first!");
8483 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
8484 return nativeResponseValue;
8487 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
8488 if(!isWasmInitialized) {
8489 throw new Error("initializeWasm() must be awaited first!");
8491 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
8492 return nativeResponseValue;
8495 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
8496 if(!isWasmInitialized) {
8497 throw new Error("initializeWasm() must be awaited first!");
8499 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
8500 return nativeResponseValue;
8503 export class LDKCOption_HTLCDestinationZ {
8504 protected constructor() {}
8507 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
8508 if(!isWasmInitialized) {
8509 throw new Error("initializeWasm() must be awaited first!");
8511 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
8512 return nativeResponseValue;
8515 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
8516 if(!isWasmInitialized) {
8517 throw new Error("initializeWasm() must be awaited first!");
8519 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
8520 return nativeResponseValue;
8522 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
8524 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
8525 if(!isWasmInitialized) {
8526 throw new Error("initializeWasm() must be awaited first!");
8528 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
8529 return nativeResponseValue;
8531 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
8533 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
8534 if(!isWasmInitialized) {
8535 throw new Error("initializeWasm() must be awaited first!");
8537 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
8538 return nativeResponseValue;
8540 // enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
8542 export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
8543 if(!isWasmInitialized) {
8544 throw new Error("initializeWasm() must be awaited first!");
8546 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
8547 return nativeResponseValue;
8549 // struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
8551 export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
8552 if(!isWasmInitialized) {
8553 throw new Error("initializeWasm() must be awaited first!");
8555 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
8556 return nativeResponseValue;
8559 export class LDKCOption_U128Z {
8560 protected constructor() {}
8563 export function LDKCOption_U128Z_ty_from_ptr(ptr: bigint): number {
8564 if(!isWasmInitialized) {
8565 throw new Error("initializeWasm() must be awaited first!");
8567 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_ty_from_ptr(ptr);
8568 return nativeResponseValue;
8571 export function LDKCOption_U128Z_Some_get_some(ptr: bigint): number {
8572 if(!isWasmInitialized) {
8573 throw new Error("initializeWasm() must be awaited first!");
8575 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_Some_get_some(ptr);
8576 return nativeResponseValue;
8579 export class LDKCOption_PaymentFailureReasonZ {
8580 protected constructor() {}
8583 export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
8584 if(!isWasmInitialized) {
8585 throw new Error("initializeWasm() must be awaited first!");
8587 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
8588 return nativeResponseValue;
8591 export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
8592 if(!isWasmInitialized) {
8593 throw new Error("initializeWasm() must be awaited first!");
8595 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
8596 return nativeResponseValue;
8599 export class LDKBumpTransactionEvent {
8600 protected constructor() {}
8603 export function LDKBumpTransactionEvent_ty_from_ptr(ptr: bigint): number {
8604 if(!isWasmInitialized) {
8605 throw new Error("initializeWasm() must be awaited first!");
8607 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ty_from_ptr(ptr);
8608 return nativeResponseValue;
8611 export function LDKBumpTransactionEvent_ChannelClose_get_channel_id(ptr: bigint): bigint {
8612 if(!isWasmInitialized) {
8613 throw new Error("initializeWasm() must be awaited first!");
8615 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_channel_id(ptr);
8616 return nativeResponseValue;
8619 export function LDKBumpTransactionEvent_ChannelClose_get_counterparty_node_id(ptr: bigint): number {
8620 if(!isWasmInitialized) {
8621 throw new Error("initializeWasm() must be awaited first!");
8623 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_counterparty_node_id(ptr);
8624 return nativeResponseValue;
8627 export function LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr: bigint): number {
8628 if(!isWasmInitialized) {
8629 throw new Error("initializeWasm() must be awaited first!");
8631 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
8632 return nativeResponseValue;
8635 export function LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr: bigint): number {
8636 if(!isWasmInitialized) {
8637 throw new Error("initializeWasm() must be awaited first!");
8639 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
8640 return nativeResponseValue;
8643 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr: bigint): number {
8644 if(!isWasmInitialized) {
8645 throw new Error("initializeWasm() must be awaited first!");
8647 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
8648 return nativeResponseValue;
8651 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr: bigint): bigint {
8652 if(!isWasmInitialized) {
8653 throw new Error("initializeWasm() must be awaited first!");
8655 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
8656 return nativeResponseValue;
8659 export function LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr: bigint): bigint {
8660 if(!isWasmInitialized) {
8661 throw new Error("initializeWasm() must be awaited first!");
8663 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
8664 return nativeResponseValue;
8667 export function LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr: bigint): number {
8668 if(!isWasmInitialized) {
8669 throw new Error("initializeWasm() must be awaited first!");
8671 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
8672 return nativeResponseValue;
8675 export function LDKBumpTransactionEvent_HTLCResolution_get_channel_id(ptr: bigint): bigint {
8676 if(!isWasmInitialized) {
8677 throw new Error("initializeWasm() must be awaited first!");
8679 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_channel_id(ptr);
8680 return nativeResponseValue;
8683 export function LDKBumpTransactionEvent_HTLCResolution_get_counterparty_node_id(ptr: bigint): number {
8684 if(!isWasmInitialized) {
8685 throw new Error("initializeWasm() must be awaited first!");
8687 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_counterparty_node_id(ptr);
8688 return nativeResponseValue;
8691 export function LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr: bigint): number {
8692 if(!isWasmInitialized) {
8693 throw new Error("initializeWasm() must be awaited first!");
8695 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
8696 return nativeResponseValue;
8699 export function LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr: bigint): number {
8700 if(!isWasmInitialized) {
8701 throw new Error("initializeWasm() must be awaited first!");
8703 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
8704 return nativeResponseValue;
8707 export function LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr: bigint): number {
8708 if(!isWasmInitialized) {
8709 throw new Error("initializeWasm() must be awaited first!");
8711 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
8712 return nativeResponseValue;
8715 export function LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr: bigint): number {
8716 if(!isWasmInitialized) {
8717 throw new Error("initializeWasm() must be awaited first!");
8719 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
8720 return nativeResponseValue;
8723 export class LDKEvent {
8724 protected constructor() {}
8727 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
8728 if(!isWasmInitialized) {
8729 throw new Error("initializeWasm() must be awaited first!");
8731 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
8732 return nativeResponseValue;
8735 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): bigint {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
8740 return nativeResponseValue;
8743 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
8744 if(!isWasmInitialized) {
8745 throw new Error("initializeWasm() must be awaited first!");
8747 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
8748 return nativeResponseValue;
8751 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
8752 if(!isWasmInitialized) {
8753 throw new Error("initializeWasm() must be awaited first!");
8755 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
8756 return nativeResponseValue;
8759 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
8760 if(!isWasmInitialized) {
8761 throw new Error("initializeWasm() must be awaited first!");
8763 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
8764 return nativeResponseValue;
8767 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
8768 if(!isWasmInitialized) {
8769 throw new Error("initializeWasm() must be awaited first!");
8771 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
8772 return nativeResponseValue;
8775 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
8776 if(!isWasmInitialized) {
8777 throw new Error("initializeWasm() must be awaited first!");
8779 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
8780 return nativeResponseValue;
8783 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
8784 if(!isWasmInitialized) {
8785 throw new Error("initializeWasm() must be awaited first!");
8787 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
8788 return nativeResponseValue;
8791 export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
8792 if(!isWasmInitialized) {
8793 throw new Error("initializeWasm() must be awaited first!");
8795 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
8796 return nativeResponseValue;
8799 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
8800 if(!isWasmInitialized) {
8801 throw new Error("initializeWasm() must be awaited first!");
8803 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
8804 return nativeResponseValue;
8807 export function LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr: bigint): bigint {
8808 if(!isWasmInitialized) {
8809 throw new Error("initializeWasm() must be awaited first!");
8811 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr);
8812 return nativeResponseValue;
8815 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
8816 if(!isWasmInitialized) {
8817 throw new Error("initializeWasm() must be awaited first!");
8819 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
8820 return nativeResponseValue;
8823 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): bigint {
8824 if(!isWasmInitialized) {
8825 throw new Error("initializeWasm() must be awaited first!");
8827 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
8828 return nativeResponseValue;
8831 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
8832 if(!isWasmInitialized) {
8833 throw new Error("initializeWasm() must be awaited first!");
8835 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
8836 return nativeResponseValue;
8839 export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
8840 if(!isWasmInitialized) {
8841 throw new Error("initializeWasm() must be awaited first!");
8843 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
8844 return nativeResponseValue;
8847 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
8848 if(!isWasmInitialized) {
8849 throw new Error("initializeWasm() must be awaited first!");
8851 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
8852 return nativeResponseValue;
8855 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
8856 if(!isWasmInitialized) {
8857 throw new Error("initializeWasm() must be awaited first!");
8859 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
8860 return nativeResponseValue;
8863 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
8864 if(!isWasmInitialized) {
8865 throw new Error("initializeWasm() must be awaited first!");
8867 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
8868 return nativeResponseValue;
8871 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
8872 if(!isWasmInitialized) {
8873 throw new Error("initializeWasm() must be awaited first!");
8875 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
8876 return nativeResponseValue;
8879 export function LDKEvent_PaymentClaimed_get_htlcs(ptr: bigint): number {
8880 if(!isWasmInitialized) {
8881 throw new Error("initializeWasm() must be awaited first!");
8883 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_htlcs(ptr);
8884 return nativeResponseValue;
8887 export function LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr: bigint): bigint {
8888 if(!isWasmInitialized) {
8889 throw new Error("initializeWasm() must be awaited first!");
8891 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr);
8892 return nativeResponseValue;
8895 export function LDKEvent_ConnectionNeeded_get_node_id(ptr: bigint): number {
8896 if(!isWasmInitialized) {
8897 throw new Error("initializeWasm() must be awaited first!");
8899 const nativeResponseValue = wasm.TS_LDKEvent_ConnectionNeeded_get_node_id(ptr);
8900 return nativeResponseValue;
8903 export function LDKEvent_ConnectionNeeded_get_addresses(ptr: bigint): number {
8904 if(!isWasmInitialized) {
8905 throw new Error("initializeWasm() must be awaited first!");
8907 const nativeResponseValue = wasm.TS_LDKEvent_ConnectionNeeded_get_addresses(ptr);
8908 return nativeResponseValue;
8911 export function LDKEvent_InvoiceRequestFailed_get_payment_id(ptr: bigint): number {
8912 if(!isWasmInitialized) {
8913 throw new Error("initializeWasm() must be awaited first!");
8915 const nativeResponseValue = wasm.TS_LDKEvent_InvoiceRequestFailed_get_payment_id(ptr);
8916 return nativeResponseValue;
8919 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): bigint {
8920 if(!isWasmInitialized) {
8921 throw new Error("initializeWasm() must be awaited first!");
8923 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
8924 return nativeResponseValue;
8927 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
8928 if(!isWasmInitialized) {
8929 throw new Error("initializeWasm() must be awaited first!");
8931 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
8932 return nativeResponseValue;
8935 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
8936 if(!isWasmInitialized) {
8937 throw new Error("initializeWasm() must be awaited first!");
8939 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
8940 return nativeResponseValue;
8943 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
8944 if(!isWasmInitialized) {
8945 throw new Error("initializeWasm() must be awaited first!");
8947 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
8948 return nativeResponseValue;
8951 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
8956 return nativeResponseValue;
8959 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
8960 if(!isWasmInitialized) {
8961 throw new Error("initializeWasm() must be awaited first!");
8963 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
8964 return nativeResponseValue;
8967 export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
8968 if(!isWasmInitialized) {
8969 throw new Error("initializeWasm() must be awaited first!");
8971 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
8972 return nativeResponseValue;
8975 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
8976 if(!isWasmInitialized) {
8977 throw new Error("initializeWasm() must be awaited first!");
8979 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
8980 return nativeResponseValue;
8983 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): bigint {
8984 if(!isWasmInitialized) {
8985 throw new Error("initializeWasm() must be awaited first!");
8987 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
8988 return nativeResponseValue;
8991 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
8992 if(!isWasmInitialized) {
8993 throw new Error("initializeWasm() must be awaited first!");
8995 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
8996 return nativeResponseValue;
8999 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): bigint {
9000 if(!isWasmInitialized) {
9001 throw new Error("initializeWasm() must be awaited first!");
9003 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
9004 return nativeResponseValue;
9007 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
9008 if(!isWasmInitialized) {
9009 throw new Error("initializeWasm() must be awaited first!");
9011 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
9012 return nativeResponseValue;
9015 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
9016 if(!isWasmInitialized) {
9017 throw new Error("initializeWasm() must be awaited first!");
9019 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
9020 return nativeResponseValue;
9023 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
9024 if(!isWasmInitialized) {
9025 throw new Error("initializeWasm() must be awaited first!");
9027 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
9028 return nativeResponseValue;
9031 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
9032 if(!isWasmInitialized) {
9033 throw new Error("initializeWasm() must be awaited first!");
9035 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
9036 return nativeResponseValue;
9039 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
9040 if(!isWasmInitialized) {
9041 throw new Error("initializeWasm() must be awaited first!");
9043 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
9044 return nativeResponseValue;
9047 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
9048 if(!isWasmInitialized) {
9049 throw new Error("initializeWasm() must be awaited first!");
9051 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
9052 return nativeResponseValue;
9055 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
9056 if(!isWasmInitialized) {
9057 throw new Error("initializeWasm() must be awaited first!");
9059 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
9060 return nativeResponseValue;
9063 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
9064 if(!isWasmInitialized) {
9065 throw new Error("initializeWasm() must be awaited first!");
9067 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
9068 return nativeResponseValue;
9071 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
9072 if(!isWasmInitialized) {
9073 throw new Error("initializeWasm() must be awaited first!");
9075 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
9076 return nativeResponseValue;
9079 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
9080 if(!isWasmInitialized) {
9081 throw new Error("initializeWasm() must be awaited first!");
9083 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
9084 return nativeResponseValue;
9087 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
9088 if(!isWasmInitialized) {
9089 throw new Error("initializeWasm() must be awaited first!");
9091 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
9092 return nativeResponseValue;
9095 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
9100 return nativeResponseValue;
9103 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
9104 if(!isWasmInitialized) {
9105 throw new Error("initializeWasm() must be awaited first!");
9107 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
9108 return nativeResponseValue;
9111 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
9112 if(!isWasmInitialized) {
9113 throw new Error("initializeWasm() must be awaited first!");
9115 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
9116 return nativeResponseValue;
9119 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
9120 if(!isWasmInitialized) {
9121 throw new Error("initializeWasm() must be awaited first!");
9123 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
9124 return nativeResponseValue;
9127 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
9128 if(!isWasmInitialized) {
9129 throw new Error("initializeWasm() must be awaited first!");
9131 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
9132 return nativeResponseValue;
9135 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
9136 if(!isWasmInitialized) {
9137 throw new Error("initializeWasm() must be awaited first!");
9139 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
9140 return nativeResponseValue;
9143 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
9144 if(!isWasmInitialized) {
9145 throw new Error("initializeWasm() must be awaited first!");
9147 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
9148 return nativeResponseValue;
9151 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
9152 if(!isWasmInitialized) {
9153 throw new Error("initializeWasm() must be awaited first!");
9155 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
9156 return nativeResponseValue;
9159 export function LDKEvent_SpendableOutputs_get_channel_id(ptr: bigint): bigint {
9160 if(!isWasmInitialized) {
9161 throw new Error("initializeWasm() must be awaited first!");
9163 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_channel_id(ptr);
9164 return nativeResponseValue;
9167 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): bigint {
9168 if(!isWasmInitialized) {
9169 throw new Error("initializeWasm() must be awaited first!");
9171 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
9172 return nativeResponseValue;
9175 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): bigint {
9176 if(!isWasmInitialized) {
9177 throw new Error("initializeWasm() must be awaited first!");
9179 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
9180 return nativeResponseValue;
9183 export function LDKEvent_PaymentForwarded_get_prev_user_channel_id(ptr: bigint): bigint {
9184 if(!isWasmInitialized) {
9185 throw new Error("initializeWasm() must be awaited first!");
9187 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_user_channel_id(ptr);
9188 return nativeResponseValue;
9191 export function LDKEvent_PaymentForwarded_get_next_user_channel_id(ptr: bigint): bigint {
9192 if(!isWasmInitialized) {
9193 throw new Error("initializeWasm() must be awaited first!");
9195 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_user_channel_id(ptr);
9196 return nativeResponseValue;
9199 export function LDKEvent_PaymentForwarded_get_total_fee_earned_msat(ptr: bigint): bigint {
9200 if(!isWasmInitialized) {
9201 throw new Error("initializeWasm() must be awaited first!");
9203 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_total_fee_earned_msat(ptr);
9204 return nativeResponseValue;
9207 export function LDKEvent_PaymentForwarded_get_skimmed_fee_msat(ptr: bigint): bigint {
9208 if(!isWasmInitialized) {
9209 throw new Error("initializeWasm() must be awaited first!");
9211 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_skimmed_fee_msat(ptr);
9212 return nativeResponseValue;
9215 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
9216 if(!isWasmInitialized) {
9217 throw new Error("initializeWasm() must be awaited first!");
9219 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
9220 return nativeResponseValue;
9223 export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
9224 if(!isWasmInitialized) {
9225 throw new Error("initializeWasm() must be awaited first!");
9227 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
9228 return nativeResponseValue;
9231 export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): bigint {
9232 if(!isWasmInitialized) {
9233 throw new Error("initializeWasm() must be awaited first!");
9235 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
9236 return nativeResponseValue;
9239 export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
9240 if(!isWasmInitialized) {
9241 throw new Error("initializeWasm() must be awaited first!");
9243 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
9244 return nativeResponseValue;
9247 export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): bigint {
9248 if(!isWasmInitialized) {
9249 throw new Error("initializeWasm() must be awaited first!");
9251 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
9252 return nativeResponseValue;
9255 export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
9256 if(!isWasmInitialized) {
9257 throw new Error("initializeWasm() must be awaited first!");
9259 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
9260 return nativeResponseValue;
9263 export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
9264 if(!isWasmInitialized) {
9265 throw new Error("initializeWasm() must be awaited first!");
9267 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
9268 return nativeResponseValue;
9271 export function LDKEvent_ChannelPending_get_channel_type(ptr: bigint): bigint {
9272 if(!isWasmInitialized) {
9273 throw new Error("initializeWasm() must be awaited first!");
9275 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_type(ptr);
9276 return nativeResponseValue;
9279 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): bigint {
9280 if(!isWasmInitialized) {
9281 throw new Error("initializeWasm() must be awaited first!");
9283 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
9284 return nativeResponseValue;
9287 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
9288 if(!isWasmInitialized) {
9289 throw new Error("initializeWasm() must be awaited first!");
9291 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
9292 return nativeResponseValue;
9295 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
9296 if(!isWasmInitialized) {
9297 throw new Error("initializeWasm() must be awaited first!");
9299 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
9300 return nativeResponseValue;
9303 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
9304 if(!isWasmInitialized) {
9305 throw new Error("initializeWasm() must be awaited first!");
9307 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
9308 return nativeResponseValue;
9311 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): bigint {
9312 if(!isWasmInitialized) {
9313 throw new Error("initializeWasm() must be awaited first!");
9315 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
9316 return nativeResponseValue;
9319 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
9320 if(!isWasmInitialized) {
9321 throw new Error("initializeWasm() must be awaited first!");
9323 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
9324 return nativeResponseValue;
9327 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
9328 if(!isWasmInitialized) {
9329 throw new Error("initializeWasm() must be awaited first!");
9331 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
9332 return nativeResponseValue;
9335 export function LDKEvent_ChannelClosed_get_counterparty_node_id(ptr: bigint): number {
9336 if(!isWasmInitialized) {
9337 throw new Error("initializeWasm() must be awaited first!");
9339 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_counterparty_node_id(ptr);
9340 return nativeResponseValue;
9343 export function LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr: bigint): bigint {
9344 if(!isWasmInitialized) {
9345 throw new Error("initializeWasm() must be awaited first!");
9347 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr);
9348 return nativeResponseValue;
9351 export function LDKEvent_ChannelClosed_get_channel_funding_txo(ptr: bigint): bigint {
9352 if(!isWasmInitialized) {
9353 throw new Error("initializeWasm() must be awaited first!");
9355 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_funding_txo(ptr);
9356 return nativeResponseValue;
9359 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): bigint {
9360 if(!isWasmInitialized) {
9361 throw new Error("initializeWasm() must be awaited first!");
9363 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
9364 return nativeResponseValue;
9367 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
9368 if(!isWasmInitialized) {
9369 throw new Error("initializeWasm() must be awaited first!");
9371 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
9372 return nativeResponseValue;
9375 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): bigint {
9376 if(!isWasmInitialized) {
9377 throw new Error("initializeWasm() must be awaited first!");
9379 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
9380 return nativeResponseValue;
9383 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
9384 if(!isWasmInitialized) {
9385 throw new Error("initializeWasm() must be awaited first!");
9387 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
9388 return nativeResponseValue;
9391 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
9392 if(!isWasmInitialized) {
9393 throw new Error("initializeWasm() must be awaited first!");
9395 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
9396 return nativeResponseValue;
9399 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
9400 if(!isWasmInitialized) {
9401 throw new Error("initializeWasm() must be awaited first!");
9403 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
9404 return nativeResponseValue;
9407 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
9408 if(!isWasmInitialized) {
9409 throw new Error("initializeWasm() must be awaited first!");
9411 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
9412 return nativeResponseValue;
9415 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): bigint {
9416 if(!isWasmInitialized) {
9417 throw new Error("initializeWasm() must be awaited first!");
9419 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
9420 return nativeResponseValue;
9423 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
9424 if(!isWasmInitialized) {
9425 throw new Error("initializeWasm() must be awaited first!");
9427 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
9428 return nativeResponseValue;
9431 export function LDKEvent_BumpTransaction_get_bump_transaction(ptr: bigint): bigint {
9432 if(!isWasmInitialized) {
9433 throw new Error("initializeWasm() must be awaited first!");
9435 const nativeResponseValue = wasm.TS_LDKEvent_BumpTransaction_get_bump_transaction(ptr);
9436 return nativeResponseValue;
9439 export class LDKCOption_EventZ {
9440 protected constructor() {}
9443 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
9444 if(!isWasmInitialized) {
9445 throw new Error("initializeWasm() must be awaited first!");
9447 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
9448 return nativeResponseValue;
9451 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
9452 if(!isWasmInitialized) {
9453 throw new Error("initializeWasm() must be awaited first!");
9455 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
9456 return nativeResponseValue;
9458 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
9460 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
9461 if(!isWasmInitialized) {
9462 throw new Error("initializeWasm() must be awaited first!");
9464 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
9465 return nativeResponseValue;
9467 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
9469 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
9470 if(!isWasmInitialized) {
9471 throw new Error("initializeWasm() must be awaited first!");
9473 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
9474 return nativeResponseValue;
9477 export class LDKBolt11ParseError {
9478 protected constructor() {}
9481 export function LDKBolt11ParseError_ty_from_ptr(ptr: bigint): number {
9482 if(!isWasmInitialized) {
9483 throw new Error("initializeWasm() must be awaited first!");
9485 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ty_from_ptr(ptr);
9486 return nativeResponseValue;
9489 export function LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
9490 if(!isWasmInitialized) {
9491 throw new Error("initializeWasm() must be awaited first!");
9493 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr);
9494 return nativeResponseValue;
9497 export function LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
9498 if(!isWasmInitialized) {
9499 throw new Error("initializeWasm() must be awaited first!");
9501 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr);
9502 return nativeResponseValue;
9505 export function LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
9506 if(!isWasmInitialized) {
9507 throw new Error("initializeWasm() must be awaited first!");
9509 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr);
9510 return nativeResponseValue;
9513 export function LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
9514 if(!isWasmInitialized) {
9515 throw new Error("initializeWasm() must be awaited first!");
9517 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr);
9518 return nativeResponseValue;
9521 export function LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
9522 if(!isWasmInitialized) {
9523 throw new Error("initializeWasm() must be awaited first!");
9525 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
9526 return nativeResponseValue;
9528 // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
9530 export function CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner: bigint): SiPrefix {
9531 if(!isWasmInitialized) {
9532 throw new Error("initializeWasm() must be awaited first!");
9534 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner);
9535 return nativeResponseValue;
9537 // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
9539 export function CResult_SiPrefixBolt11ParseErrorZ_get_err(owner: bigint): bigint {
9540 if(!isWasmInitialized) {
9541 throw new Error("initializeWasm() must be awaited first!");
9543 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(owner);
9544 return nativeResponseValue;
9547 export class LDKParseOrSemanticError {
9548 protected constructor() {}
9551 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
9552 if(!isWasmInitialized) {
9553 throw new Error("initializeWasm() must be awaited first!");
9555 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
9556 return nativeResponseValue;
9559 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
9560 if(!isWasmInitialized) {
9561 throw new Error("initializeWasm() must be awaited first!");
9563 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
9564 return nativeResponseValue;
9567 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): Bolt11SemanticError {
9568 if(!isWasmInitialized) {
9569 throw new Error("initializeWasm() must be awaited first!");
9571 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
9572 return nativeResponseValue;
9574 // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
9576 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
9577 if(!isWasmInitialized) {
9578 throw new Error("initializeWasm() must be awaited first!");
9580 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner);
9581 return nativeResponseValue;
9583 // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
9585 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
9586 if(!isWasmInitialized) {
9587 throw new Error("initializeWasm() must be awaited first!");
9589 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner);
9590 return nativeResponseValue;
9592 // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
9594 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner: bigint): bigint {
9595 if(!isWasmInitialized) {
9596 throw new Error("initializeWasm() must be awaited first!");
9598 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner);
9599 return nativeResponseValue;
9601 // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
9603 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner: bigint): bigint {
9604 if(!isWasmInitialized) {
9605 throw new Error("initializeWasm() must be awaited first!");
9607 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner);
9608 return nativeResponseValue;
9610 // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
9612 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner: bigint): bigint {
9613 if(!isWasmInitialized) {
9614 throw new Error("initializeWasm() must be awaited first!");
9616 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner);
9617 return nativeResponseValue;
9619 // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
9621 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner: bigint): number {
9622 if(!isWasmInitialized) {
9623 throw new Error("initializeWasm() must be awaited first!");
9625 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner);
9626 return nativeResponseValue;
9628 // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
9630 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner: bigint): bigint {
9631 if(!isWasmInitialized) {
9632 throw new Error("initializeWasm() must be awaited first!");
9634 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner);
9635 return nativeResponseValue;
9637 // struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
9639 export function CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner: bigint): bigint {
9640 if(!isWasmInitialized) {
9641 throw new Error("initializeWasm() must be awaited first!");
9643 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner);
9644 return nativeResponseValue;
9646 // enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
9648 export function CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
9649 if(!isWasmInitialized) {
9650 throw new Error("initializeWasm() must be awaited first!");
9652 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner);
9653 return nativeResponseValue;
9655 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
9657 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
9658 if(!isWasmInitialized) {
9659 throw new Error("initializeWasm() must be awaited first!");
9661 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
9662 return nativeResponseValue;
9664 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
9666 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
9667 if(!isWasmInitialized) {
9668 throw new Error("initializeWasm() must be awaited first!");
9670 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
9671 return nativeResponseValue;
9673 // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
9675 export function CResult_NoneBolt11SemanticErrorZ_get_ok(owner: bigint): void {
9676 if(!isWasmInitialized) {
9677 throw new Error("initializeWasm() must be awaited first!");
9679 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_ok(owner);
9680 // debug statements here
9682 // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
9684 export function CResult_NoneBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
9685 if(!isWasmInitialized) {
9686 throw new Error("initializeWasm() must be awaited first!");
9688 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_err(owner);
9689 return nativeResponseValue;
9691 // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
9693 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner: bigint): bigint {
9694 if(!isWasmInitialized) {
9695 throw new Error("initializeWasm() must be awaited first!");
9697 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner);
9698 return nativeResponseValue;
9700 // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
9702 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
9703 if(!isWasmInitialized) {
9704 throw new Error("initializeWasm() must be awaited first!");
9706 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner);
9707 return nativeResponseValue;
9709 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
9711 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
9712 if(!isWasmInitialized) {
9713 throw new Error("initializeWasm() must be awaited first!");
9715 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
9716 return nativeResponseValue;
9718 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
9720 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
9721 if(!isWasmInitialized) {
9722 throw new Error("initializeWasm() must be awaited first!");
9724 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
9725 return nativeResponseValue;
9727 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
9729 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
9730 if(!isWasmInitialized) {
9731 throw new Error("initializeWasm() must be awaited first!");
9733 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
9734 return nativeResponseValue;
9736 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
9738 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
9739 if(!isWasmInitialized) {
9740 throw new Error("initializeWasm() must be awaited first!");
9742 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
9743 return nativeResponseValue;
9745 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
9747 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
9748 if(!isWasmInitialized) {
9749 throw new Error("initializeWasm() must be awaited first!");
9751 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
9752 return nativeResponseValue;
9754 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
9756 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
9757 if(!isWasmInitialized) {
9758 throw new Error("initializeWasm() must be awaited first!");
9760 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
9761 return nativeResponseValue;
9763 // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
9765 export function CResult_BigSizeDecodeErrorZ_get_ok(owner: bigint): bigint {
9766 if(!isWasmInitialized) {
9767 throw new Error("initializeWasm() must be awaited first!");
9769 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_ok(owner);
9770 return nativeResponseValue;
9772 // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
9774 export function CResult_BigSizeDecodeErrorZ_get_err(owner: bigint): bigint {
9775 if(!isWasmInitialized) {
9776 throw new Error("initializeWasm() must be awaited first!");
9778 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_err(owner);
9779 return nativeResponseValue;
9781 // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
9783 export function CResult_HostnameDecodeErrorZ_get_ok(owner: bigint): bigint {
9784 if(!isWasmInitialized) {
9785 throw new Error("initializeWasm() must be awaited first!");
9787 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_ok(owner);
9788 return nativeResponseValue;
9790 // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
9792 export function CResult_HostnameDecodeErrorZ_get_err(owner: bigint): bigint {
9793 if(!isWasmInitialized) {
9794 throw new Error("initializeWasm() must be awaited first!");
9796 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_err(owner);
9797 return nativeResponseValue;
9799 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
9801 export function CResult_TransactionU16LenLimitedNoneZ_get_ok(owner: bigint): bigint {
9802 if(!isWasmInitialized) {
9803 throw new Error("initializeWasm() must be awaited first!");
9805 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(owner);
9806 return nativeResponseValue;
9808 // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
9810 export function CResult_TransactionU16LenLimitedNoneZ_get_err(owner: bigint): void {
9811 if(!isWasmInitialized) {
9812 throw new Error("initializeWasm() must be awaited first!");
9814 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_err(owner);
9815 // debug statements here
9817 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
9819 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner: bigint): bigint {
9820 if(!isWasmInitialized) {
9821 throw new Error("initializeWasm() must be awaited first!");
9823 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner);
9824 return nativeResponseValue;
9826 // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
9828 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner: bigint): bigint {
9829 if(!isWasmInitialized) {
9830 throw new Error("initializeWasm() must be awaited first!");
9832 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner);
9833 return nativeResponseValue;
9835 // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
9837 export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
9838 if(!isWasmInitialized) {
9839 throw new Error("initializeWasm() must be awaited first!");
9841 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
9842 return nativeResponseValue;
9844 // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
9846 export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
9847 if(!isWasmInitialized) {
9848 throw new Error("initializeWasm() must be awaited first!");
9850 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
9851 return nativeResponseValue;
9853 // struct LDKChannelId CResult_ChannelIdDecodeErrorZ_get_ok(LDKCResult_ChannelIdDecodeErrorZ *NONNULL_PTR owner);
9855 export function CResult_ChannelIdDecodeErrorZ_get_ok(owner: bigint): bigint {
9856 if(!isWasmInitialized) {
9857 throw new Error("initializeWasm() must be awaited first!");
9859 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_get_ok(owner);
9860 return nativeResponseValue;
9862 // struct LDKDecodeError CResult_ChannelIdDecodeErrorZ_get_err(LDKCResult_ChannelIdDecodeErrorZ *NONNULL_PTR owner);
9864 export function CResult_ChannelIdDecodeErrorZ_get_err(owner: bigint): bigint {
9865 if(!isWasmInitialized) {
9866 throw new Error("initializeWasm() must be awaited first!");
9868 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_get_err(owner);
9869 return nativeResponseValue;
9871 // struct LDKThirtyTwoBytes C2Tuple__u832u16Z_get_a(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
9873 export function C2Tuple__u832u16Z_get_a(owner: bigint): number {
9874 if(!isWasmInitialized) {
9875 throw new Error("initializeWasm() must be awaited first!");
9877 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_get_a(owner);
9878 return nativeResponseValue;
9880 // uint16_t C2Tuple__u832u16Z_get_b(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
9882 export function C2Tuple__u832u16Z_get_b(owner: bigint): number {
9883 if(!isWasmInitialized) {
9884 throw new Error("initializeWasm() must be awaited first!");
9886 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_get_b(owner);
9887 return nativeResponseValue;
9889 // struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
9891 export function CResult_PaymentRelayDecodeErrorZ_get_ok(owner: bigint): bigint {
9892 if(!isWasmInitialized) {
9893 throw new Error("initializeWasm() must be awaited first!");
9895 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_ok(owner);
9896 return nativeResponseValue;
9898 // struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
9900 export function CResult_PaymentRelayDecodeErrorZ_get_err(owner: bigint): bigint {
9901 if(!isWasmInitialized) {
9902 throw new Error("initializeWasm() must be awaited first!");
9904 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_err(owner);
9905 return nativeResponseValue;
9907 // struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
9909 export function CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner: bigint): bigint {
9910 if(!isWasmInitialized) {
9911 throw new Error("initializeWasm() must be awaited first!");
9913 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner);
9914 return nativeResponseValue;
9916 // struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
9918 export function CResult_PaymentConstraintsDecodeErrorZ_get_err(owner: bigint): bigint {
9919 if(!isWasmInitialized) {
9920 throw new Error("initializeWasm() must be awaited first!");
9922 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_err(owner);
9923 return nativeResponseValue;
9925 // struct LDKPaymentContext CResult_PaymentContextDecodeErrorZ_get_ok(LDKCResult_PaymentContextDecodeErrorZ *NONNULL_PTR owner);
9927 export function CResult_PaymentContextDecodeErrorZ_get_ok(owner: bigint): bigint {
9928 if(!isWasmInitialized) {
9929 throw new Error("initializeWasm() must be awaited first!");
9931 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_get_ok(owner);
9932 return nativeResponseValue;
9934 // struct LDKDecodeError CResult_PaymentContextDecodeErrorZ_get_err(LDKCResult_PaymentContextDecodeErrorZ *NONNULL_PTR owner);
9936 export function CResult_PaymentContextDecodeErrorZ_get_err(owner: bigint): bigint {
9937 if(!isWasmInitialized) {
9938 throw new Error("initializeWasm() must be awaited first!");
9940 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_get_err(owner);
9941 return nativeResponseValue;
9943 // struct LDKUnknownPaymentContext CResult_UnknownPaymentContextDecodeErrorZ_get_ok(LDKCResult_UnknownPaymentContextDecodeErrorZ *NONNULL_PTR owner);
9945 export function CResult_UnknownPaymentContextDecodeErrorZ_get_ok(owner: bigint): bigint {
9946 if(!isWasmInitialized) {
9947 throw new Error("initializeWasm() must be awaited first!");
9949 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_get_ok(owner);
9950 return nativeResponseValue;
9952 // struct LDKDecodeError CResult_UnknownPaymentContextDecodeErrorZ_get_err(LDKCResult_UnknownPaymentContextDecodeErrorZ *NONNULL_PTR owner);
9954 export function CResult_UnknownPaymentContextDecodeErrorZ_get_err(owner: bigint): bigint {
9955 if(!isWasmInitialized) {
9956 throw new Error("initializeWasm() must be awaited first!");
9958 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_get_err(owner);
9959 return nativeResponseValue;
9961 // struct LDKBolt12OfferContext CResult_Bolt12OfferContextDecodeErrorZ_get_ok(LDKCResult_Bolt12OfferContextDecodeErrorZ *NONNULL_PTR owner);
9963 export function CResult_Bolt12OfferContextDecodeErrorZ_get_ok(owner: bigint): bigint {
9964 if(!isWasmInitialized) {
9965 throw new Error("initializeWasm() must be awaited first!");
9967 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_get_ok(owner);
9968 return nativeResponseValue;
9970 // struct LDKDecodeError CResult_Bolt12OfferContextDecodeErrorZ_get_err(LDKCResult_Bolt12OfferContextDecodeErrorZ *NONNULL_PTR owner);
9972 export function CResult_Bolt12OfferContextDecodeErrorZ_get_err(owner: bigint): bigint {
9973 if(!isWasmInitialized) {
9974 throw new Error("initializeWasm() must be awaited first!");
9976 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_get_err(owner);
9977 return nativeResponseValue;
9979 // struct LDKBolt12RefundContext CResult_Bolt12RefundContextDecodeErrorZ_get_ok(LDKCResult_Bolt12RefundContextDecodeErrorZ *NONNULL_PTR owner);
9981 export function CResult_Bolt12RefundContextDecodeErrorZ_get_ok(owner: bigint): bigint {
9982 if(!isWasmInitialized) {
9983 throw new Error("initializeWasm() must be awaited first!");
9985 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_get_ok(owner);
9986 return nativeResponseValue;
9988 // struct LDKDecodeError CResult_Bolt12RefundContextDecodeErrorZ_get_err(LDKCResult_Bolt12RefundContextDecodeErrorZ *NONNULL_PTR owner);
9990 export function CResult_Bolt12RefundContextDecodeErrorZ_get_err(owner: bigint): bigint {
9991 if(!isWasmInitialized) {
9992 throw new Error("initializeWasm() must be awaited first!");
9994 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_get_err(owner);
9995 return nativeResponseValue;
9997 // struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
9999 export function CResult_StrSecp256k1ErrorZ_get_ok(owner: bigint): number {
10000 if(!isWasmInitialized) {
10001 throw new Error("initializeWasm() must be awaited first!");
10003 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_ok(owner);
10004 return nativeResponseValue;
10006 // enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
10008 export function CResult_StrSecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
10009 if(!isWasmInitialized) {
10010 throw new Error("initializeWasm() must be awaited first!");
10012 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_err(owner);
10013 return nativeResponseValue;
10015 // struct LDKThirtyTwoBytes C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
10017 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(owner: bigint): number {
10018 if(!isWasmInitialized) {
10019 throw new Error("initializeWasm() must be awaited first!");
10021 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(owner);
10022 return nativeResponseValue;
10024 // struct LDKRecipientOnionFields C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
10026 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(owner: bigint): bigint {
10027 if(!isWasmInitialized) {
10028 throw new Error("initializeWasm() must be awaited first!");
10030 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(owner);
10031 return nativeResponseValue;
10033 // struct LDKRouteParameters C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
10035 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(owner: bigint): bigint {
10036 if(!isWasmInitialized) {
10037 throw new Error("initializeWasm() must be awaited first!");
10039 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(owner);
10040 return nativeResponseValue;
10042 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
10044 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(owner: bigint): bigint {
10045 if(!isWasmInitialized) {
10046 throw new Error("initializeWasm() must be awaited first!");
10048 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(owner);
10049 return nativeResponseValue;
10051 // void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
10053 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(owner: bigint): void {
10054 if(!isWasmInitialized) {
10055 throw new Error("initializeWasm() must be awaited first!");
10057 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(owner);
10058 // debug statements here
10060 // struct LDKPublicKey C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
10062 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(owner: bigint): number {
10063 if(!isWasmInitialized) {
10064 throw new Error("initializeWasm() must be awaited first!");
10066 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(owner);
10067 return nativeResponseValue;
10069 // struct LDKOnionMessage C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
10071 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(owner: bigint): bigint {
10072 if(!isWasmInitialized) {
10073 throw new Error("initializeWasm() must be awaited first!");
10075 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(owner);
10076 return nativeResponseValue;
10078 // struct LDKCOption_CVec_SocketAddressZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
10080 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(owner: bigint): bigint {
10081 if(!isWasmInitialized) {
10082 throw new Error("initializeWasm() must be awaited first!");
10084 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(owner);
10085 return nativeResponseValue;
10088 export class LDKSendError {
10089 protected constructor() {}
10092 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
10093 if(!isWasmInitialized) {
10094 throw new Error("initializeWasm() must be awaited first!");
10096 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
10097 return nativeResponseValue;
10100 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
10101 if(!isWasmInitialized) {
10102 throw new Error("initializeWasm() must be awaited first!");
10104 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
10105 return nativeResponseValue;
10108 export function LDKSendError_InvalidFirstHop_get_invalid_first_hop(ptr: bigint): number {
10109 if(!isWasmInitialized) {
10110 throw new Error("initializeWasm() must be awaited first!");
10112 const nativeResponseValue = wasm.TS_LDKSendError_InvalidFirstHop_get_invalid_first_hop(ptr);
10113 return nativeResponseValue;
10115 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
10117 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(owner: bigint): bigint {
10118 if(!isWasmInitialized) {
10119 throw new Error("initializeWasm() must be awaited first!");
10121 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(owner);
10122 return nativeResponseValue;
10124 // struct LDKSendError CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
10126 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(owner: bigint): bigint {
10127 if(!isWasmInitialized) {
10128 throw new Error("initializeWasm() must be awaited first!");
10130 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(owner);
10131 return nativeResponseValue;
10134 export class LDKNextMessageHop {
10135 protected constructor() {}
10138 export function LDKNextMessageHop_ty_from_ptr(ptr: bigint): number {
10139 if(!isWasmInitialized) {
10140 throw new Error("initializeWasm() must be awaited first!");
10142 const nativeResponseValue = wasm.TS_LDKNextMessageHop_ty_from_ptr(ptr);
10143 return nativeResponseValue;
10146 export function LDKNextMessageHop_NodeId_get_node_id(ptr: bigint): number {
10147 if(!isWasmInitialized) {
10148 throw new Error("initializeWasm() must be awaited first!");
10150 const nativeResponseValue = wasm.TS_LDKNextMessageHop_NodeId_get_node_id(ptr);
10151 return nativeResponseValue;
10154 export function LDKNextMessageHop_ShortChannelId_get_short_channel_id(ptr: bigint): bigint {
10155 if(!isWasmInitialized) {
10156 throw new Error("initializeWasm() must be awaited first!");
10158 const nativeResponseValue = wasm.TS_LDKNextMessageHop_ShortChannelId_get_short_channel_id(ptr);
10159 return nativeResponseValue;
10162 export class LDKParsedOnionMessageContents {
10163 protected constructor() {}
10166 export function LDKParsedOnionMessageContents_ty_from_ptr(ptr: bigint): number {
10167 if(!isWasmInitialized) {
10168 throw new Error("initializeWasm() must be awaited first!");
10170 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_ty_from_ptr(ptr);
10171 return nativeResponseValue;
10174 export function LDKParsedOnionMessageContents_Offers_get_offers(ptr: bigint): bigint {
10175 if(!isWasmInitialized) {
10176 throw new Error("initializeWasm() must be awaited first!");
10178 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Offers_get_offers(ptr);
10179 return nativeResponseValue;
10182 export function LDKParsedOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
10183 if(!isWasmInitialized) {
10184 throw new Error("initializeWasm() must be awaited first!");
10186 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Custom_get_custom(ptr);
10187 return nativeResponseValue;
10190 export class LDKPeeledOnion {
10191 protected constructor() {}
10194 export function LDKPeeledOnion_ty_from_ptr(ptr: bigint): number {
10195 if(!isWasmInitialized) {
10196 throw new Error("initializeWasm() must be awaited first!");
10198 const nativeResponseValue = wasm.TS_LDKPeeledOnion_ty_from_ptr(ptr);
10199 return nativeResponseValue;
10202 export function LDKPeeledOnion_Forward_get__0(ptr: bigint): bigint {
10203 if(!isWasmInitialized) {
10204 throw new Error("initializeWasm() must be awaited first!");
10206 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__0(ptr);
10207 return nativeResponseValue;
10210 export function LDKPeeledOnion_Forward_get__1(ptr: bigint): bigint {
10211 if(!isWasmInitialized) {
10212 throw new Error("initializeWasm() must be awaited first!");
10214 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__1(ptr);
10215 return nativeResponseValue;
10218 export function LDKPeeledOnion_Receive_get__0(ptr: bigint): bigint {
10219 if(!isWasmInitialized) {
10220 throw new Error("initializeWasm() must be awaited first!");
10222 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__0(ptr);
10223 return nativeResponseValue;
10226 export function LDKPeeledOnion_Receive_get__1(ptr: bigint): number {
10227 if(!isWasmInitialized) {
10228 throw new Error("initializeWasm() must be awaited first!");
10230 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__1(ptr);
10231 return nativeResponseValue;
10234 export function LDKPeeledOnion_Receive_get__2(ptr: bigint): bigint {
10235 if(!isWasmInitialized) {
10236 throw new Error("initializeWasm() must be awaited first!");
10238 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__2(ptr);
10239 return nativeResponseValue;
10241 // struct LDKPeeledOnion CResult_PeeledOnionNoneZ_get_ok(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
10243 export function CResult_PeeledOnionNoneZ_get_ok(owner: bigint): bigint {
10244 if(!isWasmInitialized) {
10245 throw new Error("initializeWasm() must be awaited first!");
10247 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_ok(owner);
10248 return nativeResponseValue;
10250 // void CResult_PeeledOnionNoneZ_get_err(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
10252 export function CResult_PeeledOnionNoneZ_get_err(owner: bigint): void {
10253 if(!isWasmInitialized) {
10254 throw new Error("initializeWasm() must be awaited first!");
10256 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_err(owner);
10257 // debug statements here
10260 export class LDKSendSuccess {
10261 protected constructor() {}
10264 export function LDKSendSuccess_ty_from_ptr(ptr: bigint): number {
10265 if(!isWasmInitialized) {
10266 throw new Error("initializeWasm() must be awaited first!");
10268 const nativeResponseValue = wasm.TS_LDKSendSuccess_ty_from_ptr(ptr);
10269 return nativeResponseValue;
10272 export function LDKSendSuccess_BufferedAwaitingConnection_get_buffered_awaiting_connection(ptr: bigint): number {
10273 if(!isWasmInitialized) {
10274 throw new Error("initializeWasm() must be awaited first!");
10276 const nativeResponseValue = wasm.TS_LDKSendSuccess_BufferedAwaitingConnection_get_buffered_awaiting_connection(ptr);
10277 return nativeResponseValue;
10279 // struct LDKSendSuccess CResult_SendSuccessSendErrorZ_get_ok(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
10281 export function CResult_SendSuccessSendErrorZ_get_ok(owner: bigint): bigint {
10282 if(!isWasmInitialized) {
10283 throw new Error("initializeWasm() must be awaited first!");
10285 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_get_ok(owner);
10286 return nativeResponseValue;
10288 // struct LDKSendError CResult_SendSuccessSendErrorZ_get_err(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
10290 export function CResult_SendSuccessSendErrorZ_get_err(owner: bigint): bigint {
10291 if(!isWasmInitialized) {
10292 throw new Error("initializeWasm() must be awaited first!");
10294 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_get_err(owner);
10295 return nativeResponseValue;
10297 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
10299 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
10300 if(!isWasmInitialized) {
10301 throw new Error("initializeWasm() must be awaited first!");
10303 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
10304 return nativeResponseValue;
10306 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
10308 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
10309 if(!isWasmInitialized) {
10310 throw new Error("initializeWasm() must be awaited first!");
10312 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
10313 // debug statements here
10315 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
10317 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner: bigint): bigint {
10318 if(!isWasmInitialized) {
10319 throw new Error("initializeWasm() must be awaited first!");
10321 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner);
10322 return nativeResponseValue;
10324 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
10326 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner: bigint): void {
10327 if(!isWasmInitialized) {
10328 throw new Error("initializeWasm() must be awaited first!");
10330 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner);
10331 // debug statements here
10333 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
10335 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
10336 if(!isWasmInitialized) {
10337 throw new Error("initializeWasm() must be awaited first!");
10339 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
10340 return nativeResponseValue;
10342 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
10344 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
10345 if(!isWasmInitialized) {
10346 throw new Error("initializeWasm() must be awaited first!");
10348 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
10349 return nativeResponseValue;
10351 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
10353 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
10354 if(!isWasmInitialized) {
10355 throw new Error("initializeWasm() must be awaited first!");
10357 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
10358 return nativeResponseValue;
10360 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
10362 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
10363 if(!isWasmInitialized) {
10364 throw new Error("initializeWasm() must be awaited first!");
10366 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
10367 return nativeResponseValue;
10369 // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
10371 export function CResult_InvoiceErrorDecodeErrorZ_get_ok(owner: bigint): bigint {
10372 if(!isWasmInitialized) {
10373 throw new Error("initializeWasm() must be awaited first!");
10375 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(owner);
10376 return nativeResponseValue;
10378 // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
10380 export function CResult_InvoiceErrorDecodeErrorZ_get_err(owner: bigint): bigint {
10381 if(!isWasmInitialized) {
10382 throw new Error("initializeWasm() must be awaited first!");
10384 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_err(owner);
10385 return nativeResponseValue;
10387 // struct LDKTrackedSpendableOutput CResult_TrackedSpendableOutputDecodeErrorZ_get_ok(LDKCResult_TrackedSpendableOutputDecodeErrorZ *NONNULL_PTR owner);
10389 export function CResult_TrackedSpendableOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
10390 if(!isWasmInitialized) {
10391 throw new Error("initializeWasm() must be awaited first!");
10393 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_get_ok(owner);
10394 return nativeResponseValue;
10396 // struct LDKDecodeError CResult_TrackedSpendableOutputDecodeErrorZ_get_err(LDKCResult_TrackedSpendableOutputDecodeErrorZ *NONNULL_PTR owner);
10398 export function CResult_TrackedSpendableOutputDecodeErrorZ_get_err(owner: bigint): bigint {
10399 if(!isWasmInitialized) {
10400 throw new Error("initializeWasm() must be awaited first!");
10402 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_get_err(owner);
10403 return nativeResponseValue;
10406 export class LDKOutputSpendStatus {
10407 protected constructor() {}
10410 export function LDKOutputSpendStatus_ty_from_ptr(ptr: bigint): number {
10411 if(!isWasmInitialized) {
10412 throw new Error("initializeWasm() must be awaited first!");
10414 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_ty_from_ptr(ptr);
10415 return nativeResponseValue;
10418 export function LDKOutputSpendStatus_PendingInitialBroadcast_get_delayed_until_height(ptr: bigint): bigint {
10419 if(!isWasmInitialized) {
10420 throw new Error("initializeWasm() must be awaited first!");
10422 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingInitialBroadcast_get_delayed_until_height(ptr);
10423 return nativeResponseValue;
10426 export function LDKOutputSpendStatus_PendingFirstConfirmation_get_first_broadcast_hash(ptr: bigint): number {
10427 if(!isWasmInitialized) {
10428 throw new Error("initializeWasm() must be awaited first!");
10430 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingFirstConfirmation_get_first_broadcast_hash(ptr);
10431 return nativeResponseValue;
10434 export function LDKOutputSpendStatus_PendingFirstConfirmation_get_latest_broadcast_height(ptr: bigint): number {
10435 if(!isWasmInitialized) {
10436 throw new Error("initializeWasm() must be awaited first!");
10438 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingFirstConfirmation_get_latest_broadcast_height(ptr);
10439 return nativeResponseValue;
10442 export function LDKOutputSpendStatus_PendingFirstConfirmation_get_latest_spending_tx(ptr: bigint): number {
10443 if(!isWasmInitialized) {
10444 throw new Error("initializeWasm() must be awaited first!");
10446 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingFirstConfirmation_get_latest_spending_tx(ptr);
10447 return nativeResponseValue;
10450 export function LDKOutputSpendStatus_PendingThresholdConfirmations_get_first_broadcast_hash(ptr: bigint): number {
10451 if(!isWasmInitialized) {
10452 throw new Error("initializeWasm() must be awaited first!");
10454 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingThresholdConfirmations_get_first_broadcast_hash(ptr);
10455 return nativeResponseValue;
10458 export function LDKOutputSpendStatus_PendingThresholdConfirmations_get_latest_broadcast_height(ptr: bigint): number {
10459 if(!isWasmInitialized) {
10460 throw new Error("initializeWasm() must be awaited first!");
10462 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingThresholdConfirmations_get_latest_broadcast_height(ptr);
10463 return nativeResponseValue;
10466 export function LDKOutputSpendStatus_PendingThresholdConfirmations_get_latest_spending_tx(ptr: bigint): number {
10467 if(!isWasmInitialized) {
10468 throw new Error("initializeWasm() must be awaited first!");
10470 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingThresholdConfirmations_get_latest_spending_tx(ptr);
10471 return nativeResponseValue;
10474 export function LDKOutputSpendStatus_PendingThresholdConfirmations_get_confirmation_height(ptr: bigint): number {
10475 if(!isWasmInitialized) {
10476 throw new Error("initializeWasm() must be awaited first!");
10478 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingThresholdConfirmations_get_confirmation_height(ptr);
10479 return nativeResponseValue;
10482 export function LDKOutputSpendStatus_PendingThresholdConfirmations_get_confirmation_hash(ptr: bigint): number {
10483 if(!isWasmInitialized) {
10484 throw new Error("initializeWasm() must be awaited first!");
10486 const nativeResponseValue = wasm.TS_LDKOutputSpendStatus_PendingThresholdConfirmations_get_confirmation_hash(ptr);
10487 return nativeResponseValue;
10489 // struct LDKOutputSpendStatus CResult_OutputSpendStatusDecodeErrorZ_get_ok(LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR owner);
10491 export function CResult_OutputSpendStatusDecodeErrorZ_get_ok(owner: bigint): bigint {
10492 if(!isWasmInitialized) {
10493 throw new Error("initializeWasm() must be awaited first!");
10495 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_get_ok(owner);
10496 return nativeResponseValue;
10498 // struct LDKDecodeError CResult_OutputSpendStatusDecodeErrorZ_get_err(LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR owner);
10500 export function CResult_OutputSpendStatusDecodeErrorZ_get_err(owner: bigint): bigint {
10501 if(!isWasmInitialized) {
10502 throw new Error("initializeWasm() must be awaited first!");
10504 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_get_err(owner);
10505 return nativeResponseValue;
10508 export interface LDKFilter {
10509 register_tx (txid: number, script_pubkey: number): void;
10510 register_output (output: bigint): void;
10514 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
10515 if(!isWasmInitialized) {
10516 throw new Error("initializeWasm() must be awaited first!");
10518 var new_obj_idx = js_objs.length;
10519 for (var i = 0; i < js_objs.length; i++) {
10520 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10522 js_objs[i] = new WeakRef(impl);
10523 return [wasm.TS_LDKFilter_new(i), i];
10525 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
10527 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
10528 if(!isWasmInitialized) {
10529 throw new Error("initializeWasm() must be awaited first!");
10531 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
10532 // debug statements here
10534 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
10536 export function Filter_register_output(this_arg: bigint, output: bigint): void {
10537 if(!isWasmInitialized) {
10538 throw new Error("initializeWasm() must be awaited first!");
10540 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
10541 // debug statements here
10544 export class LDKCOption_FilterZ {
10545 protected constructor() {}
10548 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
10549 if(!isWasmInitialized) {
10550 throw new Error("initializeWasm() must be awaited first!");
10552 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
10553 return nativeResponseValue;
10556 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
10557 if(!isWasmInitialized) {
10558 throw new Error("initializeWasm() must be awaited first!");
10560 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
10561 return nativeResponseValue;
10564 export interface LDKChangeDestinationSource {
10565 get_change_destination_script (): bigint;
10569 export function LDKChangeDestinationSource_new(impl: LDKChangeDestinationSource): [bigint, number] {
10570 if(!isWasmInitialized) {
10571 throw new Error("initializeWasm() must be awaited first!");
10573 var new_obj_idx = js_objs.length;
10574 for (var i = 0; i < js_objs.length; i++) {
10575 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10577 js_objs[i] = new WeakRef(impl);
10578 return [wasm.TS_LDKChangeDestinationSource_new(i), i];
10580 // LDKCResult_CVec_u8ZNoneZ ChangeDestinationSource_get_change_destination_script LDKChangeDestinationSource *NONNULL_PTR this_arg
10582 export function ChangeDestinationSource_get_change_destination_script(this_arg: bigint): bigint {
10583 if(!isWasmInitialized) {
10584 throw new Error("initializeWasm() must be awaited first!");
10586 const nativeResponseValue = wasm.TS_ChangeDestinationSource_get_change_destination_script(this_arg);
10587 return nativeResponseValue;
10590 export interface LDKKVStore {
10591 read (primary_namespace: number, secondary_namespace: number, key: number): bigint;
10592 write (primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint;
10593 remove (primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint;
10594 list (primary_namespace: number, secondary_namespace: number): bigint;
10598 export function LDKKVStore_new(impl: LDKKVStore): [bigint, number] {
10599 if(!isWasmInitialized) {
10600 throw new Error("initializeWasm() must be awaited first!");
10602 var new_obj_idx = js_objs.length;
10603 for (var i = 0; i < js_objs.length; i++) {
10604 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10606 js_objs[i] = new WeakRef(impl);
10607 return [wasm.TS_LDKKVStore_new(i), i];
10609 // LDKCResult_CVec_u8ZIOErrorZ KVStore_read LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key
10611 export function KVStore_read(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number): bigint {
10612 if(!isWasmInitialized) {
10613 throw new Error("initializeWasm() must be awaited first!");
10615 const nativeResponseValue = wasm.TS_KVStore_read(this_arg, primary_namespace, secondary_namespace, key);
10616 return nativeResponseValue;
10618 // LDKCResult_NoneIOErrorZ KVStore_write LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf
10620 export function KVStore_write(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint {
10621 if(!isWasmInitialized) {
10622 throw new Error("initializeWasm() must be awaited first!");
10624 const nativeResponseValue = wasm.TS_KVStore_write(this_arg, primary_namespace, secondary_namespace, key, buf);
10625 return nativeResponseValue;
10627 // LDKCResult_NoneIOErrorZ KVStore_remove LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy
10629 export function KVStore_remove(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint {
10630 if(!isWasmInitialized) {
10631 throw new Error("initializeWasm() must be awaited first!");
10633 const nativeResponseValue = wasm.TS_KVStore_remove(this_arg, primary_namespace, secondary_namespace, key, lazy);
10634 return nativeResponseValue;
10636 // LDKCResult_CVec_StrZIOErrorZ KVStore_list LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace
10638 export function KVStore_list(this_arg: bigint, primary_namespace: number, secondary_namespace: number): bigint {
10639 if(!isWasmInitialized) {
10640 throw new Error("initializeWasm() must be awaited first!");
10642 const nativeResponseValue = wasm.TS_KVStore_list(this_arg, primary_namespace, secondary_namespace);
10643 return nativeResponseValue;
10646 export interface LDKOutputSpender {
10647 spend_spendable_outputs (descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint;
10651 export function LDKOutputSpender_new(impl: LDKOutputSpender): [bigint, number] {
10652 if(!isWasmInitialized) {
10653 throw new Error("initializeWasm() must be awaited first!");
10655 var new_obj_idx = js_objs.length;
10656 for (var i = 0; i < js_objs.length; i++) {
10657 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10659 js_objs[i] = new WeakRef(impl);
10660 return [wasm.TS_LDKOutputSpender_new(i), i];
10662 // LDKCResult_TransactionNoneZ OutputSpender_spend_spendable_outputs LDKOutputSpender *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, struct LDKCOption_u32Z locktime
10664 export function OutputSpender_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
10665 if(!isWasmInitialized) {
10666 throw new Error("initializeWasm() must be awaited first!");
10668 const nativeResponseValue = wasm.TS_OutputSpender_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
10669 return nativeResponseValue;
10671 // struct LDKOutputSweeper CResult_OutputSweeperDecodeErrorZ_get_ok(LDKCResult_OutputSweeperDecodeErrorZ *NONNULL_PTR owner);
10673 export function CResult_OutputSweeperDecodeErrorZ_get_ok(owner: bigint): bigint {
10674 if(!isWasmInitialized) {
10675 throw new Error("initializeWasm() must be awaited first!");
10677 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_get_ok(owner);
10678 return nativeResponseValue;
10680 // struct LDKDecodeError CResult_OutputSweeperDecodeErrorZ_get_err(LDKCResult_OutputSweeperDecodeErrorZ *NONNULL_PTR owner);
10682 export function CResult_OutputSweeperDecodeErrorZ_get_err(owner: bigint): bigint {
10683 if(!isWasmInitialized) {
10684 throw new Error("initializeWasm() must be awaited first!");
10686 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_get_err(owner);
10687 return nativeResponseValue;
10689 // struct LDKBestBlock C2Tuple_BestBlockOutputSweeperZ_get_a(LDKC2Tuple_BestBlockOutputSweeperZ *NONNULL_PTR owner);
10691 export function C2Tuple_BestBlockOutputSweeperZ_get_a(owner: bigint): bigint {
10692 if(!isWasmInitialized) {
10693 throw new Error("initializeWasm() must be awaited first!");
10695 const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_get_a(owner);
10696 return nativeResponseValue;
10698 // struct LDKOutputSweeper C2Tuple_BestBlockOutputSweeperZ_get_b(LDKC2Tuple_BestBlockOutputSweeperZ *NONNULL_PTR owner);
10700 export function C2Tuple_BestBlockOutputSweeperZ_get_b(owner: bigint): bigint {
10701 if(!isWasmInitialized) {
10702 throw new Error("initializeWasm() must be awaited first!");
10704 const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_get_b(owner);
10705 return nativeResponseValue;
10707 // struct LDKC2Tuple_BestBlockOutputSweeperZ *CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ *NONNULL_PTR owner);
10709 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_ok(owner: bigint): bigint {
10710 if(!isWasmInitialized) {
10711 throw new Error("initializeWasm() must be awaited first!");
10713 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_ok(owner);
10714 return nativeResponseValue;
10716 // struct LDKDecodeError CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ *NONNULL_PTR owner);
10718 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_err(owner: bigint): bigint {
10719 if(!isWasmInitialized) {
10720 throw new Error("initializeWasm() must be awaited first!");
10722 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_get_err(owner);
10723 return nativeResponseValue;
10725 // struct LDKDelayedPaymentBasepoint CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
10727 export function CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
10728 if(!isWasmInitialized) {
10729 throw new Error("initializeWasm() must be awaited first!");
10731 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(owner);
10732 return nativeResponseValue;
10734 // struct LDKDecodeError CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
10736 export function CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
10737 if(!isWasmInitialized) {
10738 throw new Error("initializeWasm() must be awaited first!");
10740 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(owner);
10741 return nativeResponseValue;
10743 // struct LDKDelayedPaymentKey CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
10745 export function CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
10746 if(!isWasmInitialized) {
10747 throw new Error("initializeWasm() must be awaited first!");
10749 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(owner);
10750 return nativeResponseValue;
10752 // struct LDKDecodeError CResult_DelayedPaymentKeyDecodeErrorZ_get_err(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
10754 export function CResult_DelayedPaymentKeyDecodeErrorZ_get_err(owner: bigint): bigint {
10755 if(!isWasmInitialized) {
10756 throw new Error("initializeWasm() must be awaited first!");
10758 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_get_err(owner);
10759 return nativeResponseValue;
10761 // struct LDKHtlcBasepoint CResult_HtlcBasepointDecodeErrorZ_get_ok(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
10763 export function CResult_HtlcBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
10764 if(!isWasmInitialized) {
10765 throw new Error("initializeWasm() must be awaited first!");
10767 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_get_ok(owner);
10768 return nativeResponseValue;
10770 // struct LDKDecodeError CResult_HtlcBasepointDecodeErrorZ_get_err(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
10772 export function CResult_HtlcBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
10773 if(!isWasmInitialized) {
10774 throw new Error("initializeWasm() must be awaited first!");
10776 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_get_err(owner);
10777 return nativeResponseValue;
10779 // struct LDKHtlcKey CResult_HtlcKeyDecodeErrorZ_get_ok(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
10781 export function CResult_HtlcKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
10782 if(!isWasmInitialized) {
10783 throw new Error("initializeWasm() must be awaited first!");
10785 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_get_ok(owner);
10786 return nativeResponseValue;
10788 // struct LDKDecodeError CResult_HtlcKeyDecodeErrorZ_get_err(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
10790 export function CResult_HtlcKeyDecodeErrorZ_get_err(owner: bigint): bigint {
10791 if(!isWasmInitialized) {
10792 throw new Error("initializeWasm() must be awaited first!");
10794 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_get_err(owner);
10795 return nativeResponseValue;
10797 // struct LDKRevocationBasepoint CResult_RevocationBasepointDecodeErrorZ_get_ok(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
10799 export function CResult_RevocationBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
10800 if(!isWasmInitialized) {
10801 throw new Error("initializeWasm() must be awaited first!");
10803 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_get_ok(owner);
10804 return nativeResponseValue;
10806 // struct LDKDecodeError CResult_RevocationBasepointDecodeErrorZ_get_err(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
10808 export function CResult_RevocationBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
10809 if(!isWasmInitialized) {
10810 throw new Error("initializeWasm() must be awaited first!");
10812 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_get_err(owner);
10813 return nativeResponseValue;
10815 // struct LDKRevocationKey CResult_RevocationKeyDecodeErrorZ_get_ok(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
10817 export function CResult_RevocationKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
10818 if(!isWasmInitialized) {
10819 throw new Error("initializeWasm() must be awaited first!");
10821 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_get_ok(owner);
10822 return nativeResponseValue;
10824 // struct LDKDecodeError CResult_RevocationKeyDecodeErrorZ_get_err(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
10826 export function CResult_RevocationKeyDecodeErrorZ_get_err(owner: bigint): bigint {
10827 if(!isWasmInitialized) {
10828 throw new Error("initializeWasm() must be awaited first!");
10830 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_get_err(owner);
10831 return nativeResponseValue;
10833 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
10835 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
10836 if(!isWasmInitialized) {
10837 throw new Error("initializeWasm() must be awaited first!");
10839 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
10840 return nativeResponseValue;
10842 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
10844 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
10845 if(!isWasmInitialized) {
10846 throw new Error("initializeWasm() must be awaited first!");
10848 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
10849 // debug statements here
10851 // struct LDKOutPoint C2Tuple_OutPointChannelIdZ_get_a(LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR owner);
10853 export function C2Tuple_OutPointChannelIdZ_get_a(owner: bigint): bigint {
10854 if(!isWasmInitialized) {
10855 throw new Error("initializeWasm() must be awaited first!");
10857 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_get_a(owner);
10858 return nativeResponseValue;
10860 // struct LDKChannelId C2Tuple_OutPointChannelIdZ_get_b(LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR owner);
10862 export function C2Tuple_OutPointChannelIdZ_get_b(owner: bigint): bigint {
10863 if(!isWasmInitialized) {
10864 throw new Error("initializeWasm() must be awaited first!");
10866 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_get_b(owner);
10867 return nativeResponseValue;
10869 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
10871 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
10872 if(!isWasmInitialized) {
10873 throw new Error("initializeWasm() must be awaited first!");
10875 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
10876 return nativeResponseValue;
10878 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
10880 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
10881 if(!isWasmInitialized) {
10882 throw new Error("initializeWasm() must be awaited first!");
10884 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
10885 return nativeResponseValue;
10888 export class LDKCandidateRouteHop {
10889 protected constructor() {}
10892 export function LDKCandidateRouteHop_ty_from_ptr(ptr: bigint): number {
10893 if(!isWasmInitialized) {
10894 throw new Error("initializeWasm() must be awaited first!");
10896 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_ty_from_ptr(ptr);
10897 return nativeResponseValue;
10900 export function LDKCandidateRouteHop_FirstHop_get_first_hop(ptr: bigint): bigint {
10901 if(!isWasmInitialized) {
10902 throw new Error("initializeWasm() must be awaited first!");
10904 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_FirstHop_get_first_hop(ptr);
10905 return nativeResponseValue;
10908 export function LDKCandidateRouteHop_PublicHop_get_public_hop(ptr: bigint): bigint {
10909 if(!isWasmInitialized) {
10910 throw new Error("initializeWasm() must be awaited first!");
10912 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_PublicHop_get_public_hop(ptr);
10913 return nativeResponseValue;
10916 export function LDKCandidateRouteHop_PrivateHop_get_private_hop(ptr: bigint): bigint {
10917 if(!isWasmInitialized) {
10918 throw new Error("initializeWasm() must be awaited first!");
10920 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_PrivateHop_get_private_hop(ptr);
10921 return nativeResponseValue;
10924 export function LDKCandidateRouteHop_Blinded_get_blinded(ptr: bigint): bigint {
10925 if(!isWasmInitialized) {
10926 throw new Error("initializeWasm() must be awaited first!");
10928 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_Blinded_get_blinded(ptr);
10929 return nativeResponseValue;
10932 export function LDKCandidateRouteHop_OneHopBlinded_get_one_hop_blinded(ptr: bigint): bigint {
10933 if(!isWasmInitialized) {
10934 throw new Error("initializeWasm() must be awaited first!");
10936 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_OneHopBlinded_get_one_hop_blinded(ptr);
10937 return nativeResponseValue;
10940 export interface LDKScoreLookUp {
10941 channel_penalty_msat (candidate: bigint, usage: bigint, score_params: bigint): bigint;
10945 export function LDKScoreLookUp_new(impl: LDKScoreLookUp): [bigint, number] {
10946 if(!isWasmInitialized) {
10947 throw new Error("initializeWasm() must be awaited first!");
10949 var new_obj_idx = js_objs.length;
10950 for (var i = 0; i < js_objs.length; i++) {
10951 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10953 js_objs[i] = new WeakRef(impl);
10954 return [wasm.TS_LDKScoreLookUp_new(i), i];
10956 // uint64_t ScoreLookUp_channel_penalty_msat LDKScoreLookUp *NONNULL_PTR this_arg, const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params
10958 export function ScoreLookUp_channel_penalty_msat(this_arg: bigint, candidate: bigint, usage: bigint, score_params: bigint): bigint {
10959 if(!isWasmInitialized) {
10960 throw new Error("initializeWasm() must be awaited first!");
10962 const nativeResponseValue = wasm.TS_ScoreLookUp_channel_penalty_msat(this_arg, candidate, usage, score_params);
10963 return nativeResponseValue;
10966 export interface LDKScoreUpdate {
10967 payment_path_failed (path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void;
10968 payment_path_successful (path: bigint, duration_since_epoch: bigint): void;
10969 probe_failed (path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void;
10970 probe_successful (path: bigint, duration_since_epoch: bigint): void;
10971 time_passed (duration_since_epoch: bigint): void;
10975 export function LDKScoreUpdate_new(impl: LDKScoreUpdate): [bigint, number] {
10976 if(!isWasmInitialized) {
10977 throw new Error("initializeWasm() must be awaited first!");
10979 var new_obj_idx = js_objs.length;
10980 for (var i = 0; i < js_objs.length; i++) {
10981 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10983 js_objs[i] = new WeakRef(impl);
10984 return [wasm.TS_LDKScoreUpdate_new(i), i];
10986 // void ScoreUpdate_payment_path_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch
10988 export function ScoreUpdate_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void {
10989 if(!isWasmInitialized) {
10990 throw new Error("initializeWasm() must be awaited first!");
10992 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_failed(this_arg, path, short_channel_id, duration_since_epoch);
10993 // debug statements here
10995 // void ScoreUpdate_payment_path_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch
10997 export function ScoreUpdate_payment_path_successful(this_arg: bigint, path: bigint, duration_since_epoch: bigint): void {
10998 if(!isWasmInitialized) {
10999 throw new Error("initializeWasm() must be awaited first!");
11001 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_successful(this_arg, path, duration_since_epoch);
11002 // debug statements here
11004 // void ScoreUpdate_probe_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch
11006 export function ScoreUpdate_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void {
11007 if(!isWasmInitialized) {
11008 throw new Error("initializeWasm() must be awaited first!");
11010 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_failed(this_arg, path, short_channel_id, duration_since_epoch);
11011 // debug statements here
11013 // void ScoreUpdate_probe_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch
11015 export function ScoreUpdate_probe_successful(this_arg: bigint, path: bigint, duration_since_epoch: bigint): void {
11016 if(!isWasmInitialized) {
11017 throw new Error("initializeWasm() must be awaited first!");
11019 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_successful(this_arg, path, duration_since_epoch);
11020 // debug statements here
11022 // void ScoreUpdate_time_passed LDKScoreUpdate *NONNULL_PTR this_arg, uint64_t duration_since_epoch
11024 export function ScoreUpdate_time_passed(this_arg: bigint, duration_since_epoch: bigint): void {
11025 if(!isWasmInitialized) {
11026 throw new Error("initializeWasm() must be awaited first!");
11028 const nativeResponseValue = wasm.TS_ScoreUpdate_time_passed(this_arg, duration_since_epoch);
11029 // debug statements here
11032 export interface LDKLockableScore {
11033 read_lock (): bigint;
11034 write_lock (): bigint;
11038 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
11039 if(!isWasmInitialized) {
11040 throw new Error("initializeWasm() must be awaited first!");
11042 var new_obj_idx = js_objs.length;
11043 for (var i = 0; i < js_objs.length; i++) {
11044 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11046 js_objs[i] = new WeakRef(impl);
11047 return [wasm.TS_LDKLockableScore_new(i), i];
11049 // LDKScoreLookUp LockableScore_read_lock LDKLockableScore *NONNULL_PTR this_arg
11051 export function LockableScore_read_lock(this_arg: bigint): bigint {
11052 if(!isWasmInitialized) {
11053 throw new Error("initializeWasm() must be awaited first!");
11055 const nativeResponseValue = wasm.TS_LockableScore_read_lock(this_arg);
11056 return nativeResponseValue;
11058 // LDKScoreUpdate LockableScore_write_lock LDKLockableScore *NONNULL_PTR this_arg
11060 export function LockableScore_write_lock(this_arg: bigint): bigint {
11061 if(!isWasmInitialized) {
11062 throw new Error("initializeWasm() must be awaited first!");
11064 const nativeResponseValue = wasm.TS_LockableScore_write_lock(this_arg);
11065 return nativeResponseValue;
11068 export interface LDKWriteableScore {
11073 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
11074 if(!isWasmInitialized) {
11075 throw new Error("initializeWasm() must be awaited first!");
11077 var new_obj_idx = js_objs.length;
11078 for (var i = 0; i < js_objs.length; i++) {
11079 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11081 js_objs[i] = new WeakRef(impl);
11082 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
11084 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
11086 export function WriteableScore_write(this_arg: bigint): number {
11087 if(!isWasmInitialized) {
11088 throw new Error("initializeWasm() must be awaited first!");
11090 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
11091 return nativeResponseValue;
11094 export interface LDKPersister {
11095 persist_manager (channel_manager: bigint): bigint;
11096 persist_graph (network_graph: bigint): bigint;
11097 persist_scorer (scorer: bigint): bigint;
11101 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
11102 if(!isWasmInitialized) {
11103 throw new Error("initializeWasm() must be awaited first!");
11105 var new_obj_idx = js_objs.length;
11106 for (var i = 0; i < js_objs.length; i++) {
11107 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11109 js_objs[i] = new WeakRef(impl);
11110 return [wasm.TS_LDKPersister_new(i), i];
11112 // LDKCResult_NoneIOErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
11114 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
11115 if(!isWasmInitialized) {
11116 throw new Error("initializeWasm() must be awaited first!");
11118 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
11119 return nativeResponseValue;
11121 // LDKCResult_NoneIOErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
11123 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
11124 if(!isWasmInitialized) {
11125 throw new Error("initializeWasm() must be awaited first!");
11127 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
11128 return nativeResponseValue;
11130 // LDKCResult_NoneIOErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
11132 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
11133 if(!isWasmInitialized) {
11134 throw new Error("initializeWasm() must be awaited first!");
11136 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
11137 return nativeResponseValue;
11140 export interface LDKPersist {
11141 persist_new_channel (channel_funding_outpoint: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
11142 update_persisted_channel (channel_funding_outpoint: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
11143 archive_persisted_channel (channel_funding_outpoint: bigint): void;
11147 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
11148 if(!isWasmInitialized) {
11149 throw new Error("initializeWasm() must be awaited first!");
11151 var new_obj_idx = js_objs.length;
11152 for (var i = 0; i < js_objs.length; i++) {
11153 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11155 js_objs[i] = new WeakRef(impl);
11156 return [wasm.TS_LDKPersist_new(i), i];
11158 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
11160 export function Persist_persist_new_channel(this_arg: bigint, channel_funding_outpoint: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
11161 if(!isWasmInitialized) {
11162 throw new Error("initializeWasm() must be awaited first!");
11164 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_funding_outpoint, data, update_id);
11165 return nativeResponseValue;
11167 // LDKChannelMonitorUpdateStatus Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
11169 export function Persist_update_persisted_channel(this_arg: bigint, channel_funding_outpoint: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
11170 if(!isWasmInitialized) {
11171 throw new Error("initializeWasm() must be awaited first!");
11173 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_funding_outpoint, update, data, update_id);
11174 return nativeResponseValue;
11176 // void Persist_archive_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_funding_outpoint
11178 export function Persist_archive_persisted_channel(this_arg: bigint, channel_funding_outpoint: bigint): void {
11179 if(!isWasmInitialized) {
11180 throw new Error("initializeWasm() must be awaited first!");
11182 const nativeResponseValue = wasm.TS_Persist_archive_persisted_channel(this_arg, channel_funding_outpoint);
11183 // debug statements here
11186 export interface LDKListen {
11187 filtered_block_connected (header: number, txdata: number, height: number): void;
11188 block_connected (block: number, height: number): void;
11189 block_disconnected (header: number, height: number): void;
11193 export function LDKListen_new(impl: LDKListen): [bigint, number] {
11194 if(!isWasmInitialized) {
11195 throw new Error("initializeWasm() must be awaited first!");
11197 var new_obj_idx = js_objs.length;
11198 for (var i = 0; i < js_objs.length; i++) {
11199 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11201 js_objs[i] = new WeakRef(impl);
11202 return [wasm.TS_LDKListen_new(i), i];
11204 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
11206 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
11207 if(!isWasmInitialized) {
11208 throw new Error("initializeWasm() must be awaited first!");
11210 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
11211 // debug statements here
11213 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
11215 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
11216 if(!isWasmInitialized) {
11217 throw new Error("initializeWasm() must be awaited first!");
11219 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
11220 // debug statements here
11222 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
11224 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
11225 if(!isWasmInitialized) {
11226 throw new Error("initializeWasm() must be awaited first!");
11228 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
11229 // debug statements here
11232 export interface LDKConfirm {
11233 transactions_confirmed (header: number, txdata: number, height: number): void;
11234 transaction_unconfirmed (txid: number): void;
11235 best_block_updated (header: number, height: number): void;
11236 get_relevant_txids (): number;
11240 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
11241 if(!isWasmInitialized) {
11242 throw new Error("initializeWasm() must be awaited first!");
11244 var new_obj_idx = js_objs.length;
11245 for (var i = 0; i < js_objs.length; i++) {
11246 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11248 js_objs[i] = new WeakRef(impl);
11249 return [wasm.TS_LDKConfirm_new(i), i];
11251 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
11253 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
11254 if(!isWasmInitialized) {
11255 throw new Error("initializeWasm() must be awaited first!");
11257 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
11258 // debug statements here
11260 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
11262 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
11263 if(!isWasmInitialized) {
11264 throw new Error("initializeWasm() must be awaited first!");
11266 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
11267 // debug statements here
11269 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
11271 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
11272 if(!isWasmInitialized) {
11273 throw new Error("initializeWasm() must be awaited first!");
11275 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
11276 // debug statements here
11278 // LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
11280 export function Confirm_get_relevant_txids(this_arg: bigint): number {
11281 if(!isWasmInitialized) {
11282 throw new Error("initializeWasm() must be awaited first!");
11284 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
11285 return nativeResponseValue;
11288 export class LDKSpendingDelay {
11289 protected constructor() {}
11292 export function LDKSpendingDelay_ty_from_ptr(ptr: bigint): number {
11293 if(!isWasmInitialized) {
11294 throw new Error("initializeWasm() must be awaited first!");
11296 const nativeResponseValue = wasm.TS_LDKSpendingDelay_ty_from_ptr(ptr);
11297 return nativeResponseValue;
11300 export function LDKSpendingDelay_Relative_get_num_blocks(ptr: bigint): number {
11301 if(!isWasmInitialized) {
11302 throw new Error("initializeWasm() must be awaited first!");
11304 const nativeResponseValue = wasm.TS_LDKSpendingDelay_Relative_get_num_blocks(ptr);
11305 return nativeResponseValue;
11308 export function LDKSpendingDelay_Absolute_get_height(ptr: bigint): number {
11309 if(!isWasmInitialized) {
11310 throw new Error("initializeWasm() must be awaited first!");
11312 const nativeResponseValue = wasm.TS_LDKSpendingDelay_Absolute_get_height(ptr);
11313 return nativeResponseValue;
11316 export interface LDKFutureCallback {
11321 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
11322 if(!isWasmInitialized) {
11323 throw new Error("initializeWasm() must be awaited first!");
11325 var new_obj_idx = js_objs.length;
11326 for (var i = 0; i < js_objs.length; i++) {
11327 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11329 js_objs[i] = new WeakRef(impl);
11330 return [wasm.TS_LDKFutureCallback_new(i), i];
11332 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
11334 export function FutureCallback_call(this_arg: bigint): void {
11335 if(!isWasmInitialized) {
11336 throw new Error("initializeWasm() must be awaited first!");
11338 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
11339 // debug statements here
11342 export interface LDKEventHandler {
11343 handle_event (event: bigint): void;
11347 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
11348 if(!isWasmInitialized) {
11349 throw new Error("initializeWasm() must be awaited first!");
11351 var new_obj_idx = js_objs.length;
11352 for (var i = 0; i < js_objs.length; i++) {
11353 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11355 js_objs[i] = new WeakRef(impl);
11356 return [wasm.TS_LDKEventHandler_new(i), i];
11358 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
11360 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
11361 if(!isWasmInitialized) {
11362 throw new Error("initializeWasm() must be awaited first!");
11364 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
11365 // debug statements here
11368 export interface LDKEventsProvider {
11369 process_pending_events (handler: bigint): void;
11373 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
11374 if(!isWasmInitialized) {
11375 throw new Error("initializeWasm() must be awaited first!");
11377 var new_obj_idx = js_objs.length;
11378 for (var i = 0; i < js_objs.length; i++) {
11379 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11381 js_objs[i] = new WeakRef(impl);
11382 return [wasm.TS_LDKEventsProvider_new(i), i];
11384 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
11386 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
11387 if(!isWasmInitialized) {
11388 throw new Error("initializeWasm() must be awaited first!");
11390 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
11391 // debug statements here
11394 export class LDKFailureCode {
11395 protected constructor() {}
11398 export function LDKFailureCode_ty_from_ptr(ptr: bigint): number {
11399 if(!isWasmInitialized) {
11400 throw new Error("initializeWasm() must be awaited first!");
11402 const nativeResponseValue = wasm.TS_LDKFailureCode_ty_from_ptr(ptr);
11403 return nativeResponseValue;
11406 export function LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr: bigint): bigint {
11407 if(!isWasmInitialized) {
11408 throw new Error("initializeWasm() must be awaited first!");
11410 const nativeResponseValue = wasm.TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr);
11411 return nativeResponseValue;
11414 export interface LDKMessageSendEventsProvider {
11415 get_and_clear_pending_msg_events (): number;
11419 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
11420 if(!isWasmInitialized) {
11421 throw new Error("initializeWasm() must be awaited first!");
11423 var new_obj_idx = js_objs.length;
11424 for (var i = 0; i < js_objs.length; i++) {
11425 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11427 js_objs[i] = new WeakRef(impl);
11428 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
11430 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
11432 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
11433 if(!isWasmInitialized) {
11434 throw new Error("initializeWasm() must be awaited first!");
11436 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
11437 return nativeResponseValue;
11440 export interface LDKChannelMessageHandler {
11441 handle_open_channel (their_node_id: number, msg: bigint): void;
11442 handle_open_channel_v2 (their_node_id: number, msg: bigint): void;
11443 handle_accept_channel (their_node_id: number, msg: bigint): void;
11444 handle_accept_channel_v2 (their_node_id: number, msg: bigint): void;
11445 handle_funding_created (their_node_id: number, msg: bigint): void;
11446 handle_funding_signed (their_node_id: number, msg: bigint): void;
11447 handle_channel_ready (their_node_id: number, msg: bigint): void;
11448 handle_shutdown (their_node_id: number, msg: bigint): void;
11449 handle_closing_signed (their_node_id: number, msg: bigint): void;
11450 handle_stfu (their_node_id: number, msg: bigint): void;
11451 handle_tx_add_input (their_node_id: number, msg: bigint): void;
11452 handle_tx_add_output (their_node_id: number, msg: bigint): void;
11453 handle_tx_remove_input (their_node_id: number, msg: bigint): void;
11454 handle_tx_remove_output (their_node_id: number, msg: bigint): void;
11455 handle_tx_complete (their_node_id: number, msg: bigint): void;
11456 handle_tx_signatures (their_node_id: number, msg: bigint): void;
11457 handle_tx_init_rbf (their_node_id: number, msg: bigint): void;
11458 handle_tx_ack_rbf (their_node_id: number, msg: bigint): void;
11459 handle_tx_abort (their_node_id: number, msg: bigint): void;
11460 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
11461 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
11462 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
11463 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
11464 handle_commitment_signed (their_node_id: number, msg: bigint): void;
11465 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
11466 handle_update_fee (their_node_id: number, msg: bigint): void;
11467 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
11468 peer_disconnected (their_node_id: number): void;
11469 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
11470 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
11471 handle_channel_update (their_node_id: number, msg: bigint): void;
11472 handle_error (their_node_id: number, msg: bigint): void;
11473 provided_node_features (): bigint;
11474 provided_init_features (their_node_id: number): bigint;
11475 get_chain_hashes (): bigint;
11479 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
11480 if(!isWasmInitialized) {
11481 throw new Error("initializeWasm() must be awaited first!");
11483 var new_obj_idx = js_objs.length;
11484 for (var i = 0; i < js_objs.length; i++) {
11485 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11487 js_objs[i] = new WeakRef(impl);
11488 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
11490 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
11492 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
11493 if(!isWasmInitialized) {
11494 throw new Error("initializeWasm() must be awaited first!");
11496 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
11497 // debug statements here
11499 // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
11501 export function ChannelMessageHandler_handle_open_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
11502 if(!isWasmInitialized) {
11503 throw new Error("initializeWasm() must be awaited first!");
11505 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel_v2(this_arg, their_node_id, msg);
11506 // debug statements here
11508 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
11510 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
11511 if(!isWasmInitialized) {
11512 throw new Error("initializeWasm() must be awaited first!");
11514 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
11515 // debug statements here
11517 // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
11519 export function ChannelMessageHandler_handle_accept_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
11520 if(!isWasmInitialized) {
11521 throw new Error("initializeWasm() must be awaited first!");
11523 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel_v2(this_arg, their_node_id, msg);
11524 // debug statements here
11526 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
11528 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
11529 if(!isWasmInitialized) {
11530 throw new Error("initializeWasm() must be awaited first!");
11532 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
11533 // debug statements here
11535 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
11537 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
11538 if(!isWasmInitialized) {
11539 throw new Error("initializeWasm() must be awaited first!");
11541 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
11542 // debug statements here
11544 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
11546 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
11547 if(!isWasmInitialized) {
11548 throw new Error("initializeWasm() must be awaited first!");
11550 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
11551 // debug statements here
11553 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
11555 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
11556 if(!isWasmInitialized) {
11557 throw new Error("initializeWasm() must be awaited first!");
11559 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
11560 // debug statements here
11562 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
11564 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
11565 if(!isWasmInitialized) {
11566 throw new Error("initializeWasm() must be awaited first!");
11568 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
11569 // debug statements here
11571 // void ChannelMessageHandler_handle_stfu LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg
11573 export function ChannelMessageHandler_handle_stfu(this_arg: bigint, their_node_id: number, msg: bigint): void {
11574 if(!isWasmInitialized) {
11575 throw new Error("initializeWasm() must be awaited first!");
11577 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_stfu(this_arg, their_node_id, msg);
11578 // debug statements here
11580 // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
11582 export function ChannelMessageHandler_handle_tx_add_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
11583 if(!isWasmInitialized) {
11584 throw new Error("initializeWasm() must be awaited first!");
11586 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_input(this_arg, their_node_id, msg);
11587 // debug statements here
11589 // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
11591 export function ChannelMessageHandler_handle_tx_add_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
11592 if(!isWasmInitialized) {
11593 throw new Error("initializeWasm() must be awaited first!");
11595 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_output(this_arg, their_node_id, msg);
11596 // debug statements here
11598 // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
11600 export function ChannelMessageHandler_handle_tx_remove_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
11601 if(!isWasmInitialized) {
11602 throw new Error("initializeWasm() must be awaited first!");
11604 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_input(this_arg, their_node_id, msg);
11605 // debug statements here
11607 // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
11609 export function ChannelMessageHandler_handle_tx_remove_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
11610 if(!isWasmInitialized) {
11611 throw new Error("initializeWasm() must be awaited first!");
11613 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_output(this_arg, their_node_id, msg);
11614 // debug statements here
11616 // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
11618 export function ChannelMessageHandler_handle_tx_complete(this_arg: bigint, their_node_id: number, msg: bigint): void {
11619 if(!isWasmInitialized) {
11620 throw new Error("initializeWasm() must be awaited first!");
11622 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_complete(this_arg, their_node_id, msg);
11623 // debug statements here
11625 // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
11627 export function ChannelMessageHandler_handle_tx_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
11628 if(!isWasmInitialized) {
11629 throw new Error("initializeWasm() must be awaited first!");
11631 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_signatures(this_arg, their_node_id, msg);
11632 // debug statements here
11634 // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
11636 export function ChannelMessageHandler_handle_tx_init_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
11637 if(!isWasmInitialized) {
11638 throw new Error("initializeWasm() must be awaited first!");
11640 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_init_rbf(this_arg, their_node_id, msg);
11641 // debug statements here
11643 // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
11645 export function ChannelMessageHandler_handle_tx_ack_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
11646 if(!isWasmInitialized) {
11647 throw new Error("initializeWasm() must be awaited first!");
11649 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_ack_rbf(this_arg, their_node_id, msg);
11650 // debug statements here
11652 // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
11654 export function ChannelMessageHandler_handle_tx_abort(this_arg: bigint, their_node_id: number, msg: bigint): void {
11655 if(!isWasmInitialized) {
11656 throw new Error("initializeWasm() must be awaited first!");
11658 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_abort(this_arg, their_node_id, msg);
11659 // debug statements here
11661 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
11663 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
11664 if(!isWasmInitialized) {
11665 throw new Error("initializeWasm() must be awaited first!");
11667 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
11668 // debug statements here
11670 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
11672 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
11673 if(!isWasmInitialized) {
11674 throw new Error("initializeWasm() must be awaited first!");
11676 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
11677 // debug statements here
11679 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
11681 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
11682 if(!isWasmInitialized) {
11683 throw new Error("initializeWasm() must be awaited first!");
11685 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
11686 // debug statements here
11688 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
11690 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
11691 if(!isWasmInitialized) {
11692 throw new Error("initializeWasm() must be awaited first!");
11694 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
11695 // debug statements here
11697 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
11699 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
11700 if(!isWasmInitialized) {
11701 throw new Error("initializeWasm() must be awaited first!");
11703 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
11704 // debug statements here
11706 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
11708 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
11709 if(!isWasmInitialized) {
11710 throw new Error("initializeWasm() must be awaited first!");
11712 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
11713 // debug statements here
11715 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
11717 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
11718 if(!isWasmInitialized) {
11719 throw new Error("initializeWasm() must be awaited first!");
11721 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
11722 // debug statements here
11724 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
11726 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
11727 if(!isWasmInitialized) {
11728 throw new Error("initializeWasm() must be awaited first!");
11730 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
11731 // debug statements here
11733 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
11735 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
11736 if(!isWasmInitialized) {
11737 throw new Error("initializeWasm() must be awaited first!");
11739 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
11740 // debug statements here
11742 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
11744 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
11745 if(!isWasmInitialized) {
11746 throw new Error("initializeWasm() must be awaited first!");
11748 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
11749 return nativeResponseValue;
11751 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
11753 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
11754 if(!isWasmInitialized) {
11755 throw new Error("initializeWasm() must be awaited first!");
11757 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
11758 // debug statements here
11760 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
11762 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
11763 if(!isWasmInitialized) {
11764 throw new Error("initializeWasm() must be awaited first!");
11766 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
11767 // debug statements here
11769 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
11771 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
11772 if(!isWasmInitialized) {
11773 throw new Error("initializeWasm() must be awaited first!");
11775 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
11776 // debug statements here
11778 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
11780 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
11781 if(!isWasmInitialized) {
11782 throw new Error("initializeWasm() must be awaited first!");
11784 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
11785 return nativeResponseValue;
11787 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
11789 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
11790 if(!isWasmInitialized) {
11791 throw new Error("initializeWasm() must be awaited first!");
11793 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
11794 return nativeResponseValue;
11796 // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_chain_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
11798 export function ChannelMessageHandler_get_chain_hashes(this_arg: bigint): bigint {
11799 if(!isWasmInitialized) {
11800 throw new Error("initializeWasm() must be awaited first!");
11802 const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_chain_hashes(this_arg);
11803 return nativeResponseValue;
11806 export interface LDKOffersMessageHandler {
11807 handle_message (message: bigint): bigint;
11808 release_pending_messages (): number;
11812 export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
11813 if(!isWasmInitialized) {
11814 throw new Error("initializeWasm() must be awaited first!");
11816 var new_obj_idx = js_objs.length;
11817 for (var i = 0; i < js_objs.length; i++) {
11818 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11820 js_objs[i] = new WeakRef(impl);
11821 return [wasm.TS_LDKOffersMessageHandler_new(i), i];
11823 // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
11825 export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
11826 if(!isWasmInitialized) {
11827 throw new Error("initializeWasm() must be awaited first!");
11829 const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
11830 return nativeResponseValue;
11832 // LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler_release_pending_messages LDKOffersMessageHandler *NONNULL_PTR this_arg
11834 export function OffersMessageHandler_release_pending_messages(this_arg: bigint): number {
11835 if(!isWasmInitialized) {
11836 throw new Error("initializeWasm() must be awaited first!");
11838 const nativeResponseValue = wasm.TS_OffersMessageHandler_release_pending_messages(this_arg);
11839 return nativeResponseValue;
11842 export interface LDKNodeIdLookUp {
11843 next_node_id (short_channel_id: bigint): number;
11847 export function LDKNodeIdLookUp_new(impl: LDKNodeIdLookUp): [bigint, number] {
11848 if(!isWasmInitialized) {
11849 throw new Error("initializeWasm() must be awaited first!");
11851 var new_obj_idx = js_objs.length;
11852 for (var i = 0; i < js_objs.length; i++) {
11853 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11855 js_objs[i] = new WeakRef(impl);
11856 return [wasm.TS_LDKNodeIdLookUp_new(i), i];
11858 // LDKPublicKey NodeIdLookUp_next_node_id LDKNodeIdLookUp *NONNULL_PTR this_arg, uint64_t short_channel_id
11860 export function NodeIdLookUp_next_node_id(this_arg: bigint, short_channel_id: bigint): number {
11861 if(!isWasmInitialized) {
11862 throw new Error("initializeWasm() must be awaited first!");
11864 const nativeResponseValue = wasm.TS_NodeIdLookUp_next_node_id(this_arg, short_channel_id);
11865 return nativeResponseValue;
11868 export interface LDKRoutingMessageHandler {
11869 handle_node_announcement (msg: bigint): bigint;
11870 handle_channel_announcement (msg: bigint): bigint;
11871 handle_channel_update (msg: bigint): bigint;
11872 get_next_channel_announcement (starting_point: bigint): bigint;
11873 get_next_node_announcement (starting_point: bigint): bigint;
11874 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
11875 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
11876 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
11877 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
11878 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
11879 processing_queue_high (): boolean;
11880 provided_node_features (): bigint;
11881 provided_init_features (their_node_id: number): bigint;
11885 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
11886 if(!isWasmInitialized) {
11887 throw new Error("initializeWasm() must be awaited first!");
11889 var new_obj_idx = js_objs.length;
11890 for (var i = 0; i < js_objs.length; i++) {
11891 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11893 js_objs[i] = new WeakRef(impl);
11894 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
11896 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
11898 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
11899 if(!isWasmInitialized) {
11900 throw new Error("initializeWasm() must be awaited first!");
11902 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
11903 return nativeResponseValue;
11905 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
11907 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
11908 if(!isWasmInitialized) {
11909 throw new Error("initializeWasm() must be awaited first!");
11911 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
11912 return nativeResponseValue;
11914 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
11916 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
11917 if(!isWasmInitialized) {
11918 throw new Error("initializeWasm() must be awaited first!");
11920 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
11921 return nativeResponseValue;
11923 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
11925 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
11926 if(!isWasmInitialized) {
11927 throw new Error("initializeWasm() must be awaited first!");
11929 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
11930 return nativeResponseValue;
11932 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
11934 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
11935 if(!isWasmInitialized) {
11936 throw new Error("initializeWasm() must be awaited first!");
11938 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
11939 return nativeResponseValue;
11941 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
11943 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
11944 if(!isWasmInitialized) {
11945 throw new Error("initializeWasm() must be awaited first!");
11947 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
11948 return nativeResponseValue;
11950 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
11952 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
11953 if(!isWasmInitialized) {
11954 throw new Error("initializeWasm() must be awaited first!");
11956 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
11957 return nativeResponseValue;
11959 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
11961 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
11962 if(!isWasmInitialized) {
11963 throw new Error("initializeWasm() must be awaited first!");
11965 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
11966 return nativeResponseValue;
11968 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
11970 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
11971 if(!isWasmInitialized) {
11972 throw new Error("initializeWasm() must be awaited first!");
11974 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
11975 return nativeResponseValue;
11977 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
11979 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
11980 if(!isWasmInitialized) {
11981 throw new Error("initializeWasm() must be awaited first!");
11983 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
11984 return nativeResponseValue;
11986 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
11988 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
11989 if(!isWasmInitialized) {
11990 throw new Error("initializeWasm() must be awaited first!");
11992 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
11993 return nativeResponseValue;
11995 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
11997 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
11998 if(!isWasmInitialized) {
11999 throw new Error("initializeWasm() must be awaited first!");
12001 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
12002 return nativeResponseValue;
12004 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
12006 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
12007 if(!isWasmInitialized) {
12008 throw new Error("initializeWasm() must be awaited first!");
12010 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
12011 return nativeResponseValue;
12014 export interface LDKOnionMessageHandler {
12015 get_and_clear_connections_needed (): number;
12016 handle_onion_message (peer_node_id: number, msg: bigint): void;
12017 next_onion_message_for_peer (peer_node_id: number): bigint;
12018 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
12019 peer_disconnected (their_node_id: number): void;
12020 timer_tick_occurred (): void;
12021 provided_node_features (): bigint;
12022 provided_init_features (their_node_id: number): bigint;
12026 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler): [bigint, number] {
12027 if(!isWasmInitialized) {
12028 throw new Error("initializeWasm() must be awaited first!");
12030 var new_obj_idx = js_objs.length;
12031 for (var i = 0; i < js_objs.length; i++) {
12032 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12034 js_objs[i] = new WeakRef(impl);
12035 return [wasm.TS_LDKOnionMessageHandler_new(i), i];
12037 // LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler_get_and_clear_connections_needed LDKOnionMessageHandler *NONNULL_PTR this_arg
12039 export function OnionMessageHandler_get_and_clear_connections_needed(this_arg: bigint): number {
12040 if(!isWasmInitialized) {
12041 throw new Error("initializeWasm() must be awaited first!");
12043 const nativeResponseValue = wasm.TS_OnionMessageHandler_get_and_clear_connections_needed(this_arg);
12044 return nativeResponseValue;
12046 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
12048 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
12049 if(!isWasmInitialized) {
12050 throw new Error("initializeWasm() must be awaited first!");
12052 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
12053 // debug statements here
12055 // LDKOnionMessage OnionMessageHandler_next_onion_message_for_peer LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
12057 export function OnionMessageHandler_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
12058 if(!isWasmInitialized) {
12059 throw new Error("initializeWasm() must be awaited first!");
12061 const nativeResponseValue = wasm.TS_OnionMessageHandler_next_onion_message_for_peer(this_arg, peer_node_id);
12062 return nativeResponseValue;
12064 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
12066 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
12067 if(!isWasmInitialized) {
12068 throw new Error("initializeWasm() must be awaited first!");
12070 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
12071 return nativeResponseValue;
12073 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
12075 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
12076 if(!isWasmInitialized) {
12077 throw new Error("initializeWasm() must be awaited first!");
12079 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
12080 // debug statements here
12082 // void OnionMessageHandler_timer_tick_occurred LDKOnionMessageHandler *NONNULL_PTR this_arg
12084 export function OnionMessageHandler_timer_tick_occurred(this_arg: bigint): void {
12085 if(!isWasmInitialized) {
12086 throw new Error("initializeWasm() must be awaited first!");
12088 const nativeResponseValue = wasm.TS_OnionMessageHandler_timer_tick_occurred(this_arg);
12089 // debug statements here
12091 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
12093 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
12094 if(!isWasmInitialized) {
12095 throw new Error("initializeWasm() must be awaited first!");
12097 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
12098 return nativeResponseValue;
12100 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
12102 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
12103 if(!isWasmInitialized) {
12104 throw new Error("initializeWasm() must be awaited first!");
12106 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
12107 return nativeResponseValue;
12110 export interface LDKCustomMessageReader {
12111 read (message_type: number, buffer: number): bigint;
12115 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
12116 if(!isWasmInitialized) {
12117 throw new Error("initializeWasm() must be awaited first!");
12119 var new_obj_idx = js_objs.length;
12120 for (var i = 0; i < js_objs.length; i++) {
12121 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12123 js_objs[i] = new WeakRef(impl);
12124 return [wasm.TS_LDKCustomMessageReader_new(i), i];
12126 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
12128 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
12129 if(!isWasmInitialized) {
12130 throw new Error("initializeWasm() must be awaited first!");
12132 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
12133 return nativeResponseValue;
12136 export interface LDKCustomMessageHandler {
12137 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
12138 get_and_clear_pending_msg (): number;
12139 provided_node_features (): bigint;
12140 provided_init_features (their_node_id: number): bigint;
12144 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
12145 if(!isWasmInitialized) {
12146 throw new Error("initializeWasm() must be awaited first!");
12148 var new_obj_idx = js_objs.length;
12149 for (var i = 0; i < js_objs.length; i++) {
12150 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12152 js_objs[i] = new WeakRef(impl);
12153 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
12155 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
12157 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
12158 if(!isWasmInitialized) {
12159 throw new Error("initializeWasm() must be awaited first!");
12161 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
12162 return nativeResponseValue;
12164 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
12166 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
12167 if(!isWasmInitialized) {
12168 throw new Error("initializeWasm() must be awaited first!");
12170 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
12171 return nativeResponseValue;
12173 // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
12175 export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
12176 if(!isWasmInitialized) {
12177 throw new Error("initializeWasm() must be awaited first!");
12179 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
12180 return nativeResponseValue;
12182 // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
12184 export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
12185 if(!isWasmInitialized) {
12186 throw new Error("initializeWasm() must be awaited first!");
12188 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
12189 return nativeResponseValue;
12192 export interface LDKCustomOnionMessageHandler {
12193 handle_custom_message (msg: bigint): bigint;
12194 read_custom_message (message_type: bigint, buffer: number): bigint;
12195 release_pending_custom_messages (): number;
12199 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
12200 if(!isWasmInitialized) {
12201 throw new Error("initializeWasm() must be awaited first!");
12203 var new_obj_idx = js_objs.length;
12204 for (var i = 0; i < js_objs.length; i++) {
12205 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12207 js_objs[i] = new WeakRef(impl);
12208 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
12210 // LDKCOption_OnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKOnionMessageContents msg
12212 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
12213 if(!isWasmInitialized) {
12214 throw new Error("initializeWasm() must be awaited first!");
12216 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
12217 return nativeResponseValue;
12219 // LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
12221 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
12222 if(!isWasmInitialized) {
12223 throw new Error("initializeWasm() must be awaited first!");
12225 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
12226 return nativeResponseValue;
12228 // LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler_release_pending_custom_messages LDKCustomOnionMessageHandler *NONNULL_PTR this_arg
12230 export function CustomOnionMessageHandler_release_pending_custom_messages(this_arg: bigint): number {
12231 if(!isWasmInitialized) {
12232 throw new Error("initializeWasm() must be awaited first!");
12234 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_release_pending_custom_messages(this_arg);
12235 return nativeResponseValue;
12238 export interface LDKSocketDescriptor {
12239 send_data (data: number, resume_read: boolean): number;
12240 disconnect_socket (): void;
12241 eq (other_arg: bigint): boolean;
12246 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
12247 if(!isWasmInitialized) {
12248 throw new Error("initializeWasm() must be awaited first!");
12250 var new_obj_idx = js_objs.length;
12251 for (var i = 0; i < js_objs.length; i++) {
12252 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12254 js_objs[i] = new WeakRef(impl);
12255 return [wasm.TS_LDKSocketDescriptor_new(i), i];
12257 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
12259 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
12260 if(!isWasmInitialized) {
12261 throw new Error("initializeWasm() must be awaited first!");
12263 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
12264 return nativeResponseValue;
12266 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
12268 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
12269 if(!isWasmInitialized) {
12270 throw new Error("initializeWasm() must be awaited first!");
12272 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
12273 // debug statements here
12275 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
12277 export function SocketDescriptor_hash(this_arg: bigint): bigint {
12278 if(!isWasmInitialized) {
12279 throw new Error("initializeWasm() must be awaited first!");
12281 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
12282 return nativeResponseValue;
12285 export interface LDKSignBolt12InvoiceFn {
12286 sign_invoice (message: bigint): bigint;
12290 export function LDKSignBolt12InvoiceFn_new(impl: LDKSignBolt12InvoiceFn): [bigint, number] {
12291 if(!isWasmInitialized) {
12292 throw new Error("initializeWasm() must be awaited first!");
12294 var new_obj_idx = js_objs.length;
12295 for (var i = 0; i < js_objs.length; i++) {
12296 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12298 js_objs[i] = new WeakRef(impl);
12299 return [wasm.TS_LDKSignBolt12InvoiceFn_new(i), i];
12301 // LDKCResult_SchnorrSignatureNoneZ SignBolt12InvoiceFn_sign_invoice LDKSignBolt12InvoiceFn *NONNULL_PTR this_arg, const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message
12303 export function SignBolt12InvoiceFn_sign_invoice(this_arg: bigint, message: bigint): bigint {
12304 if(!isWasmInitialized) {
12305 throw new Error("initializeWasm() must be awaited first!");
12307 const nativeResponseValue = wasm.TS_SignBolt12InvoiceFn_sign_invoice(this_arg, message);
12308 return nativeResponseValue;
12311 export interface LDKSignInvoiceRequestFn {
12312 sign_invoice_request (message: bigint): bigint;
12316 export function LDKSignInvoiceRequestFn_new(impl: LDKSignInvoiceRequestFn): [bigint, number] {
12317 if(!isWasmInitialized) {
12318 throw new Error("initializeWasm() must be awaited first!");
12320 var new_obj_idx = js_objs.length;
12321 for (var i = 0; i < js_objs.length; i++) {
12322 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12324 js_objs[i] = new WeakRef(impl);
12325 return [wasm.TS_LDKSignInvoiceRequestFn_new(i), i];
12327 // LDKCResult_SchnorrSignatureNoneZ SignInvoiceRequestFn_sign_invoice_request LDKSignInvoiceRequestFn *NONNULL_PTR this_arg, const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message
12329 export function SignInvoiceRequestFn_sign_invoice_request(this_arg: bigint, message: bigint): bigint {
12330 if(!isWasmInitialized) {
12331 throw new Error("initializeWasm() must be awaited first!");
12333 const nativeResponseValue = wasm.TS_SignInvoiceRequestFn_sign_invoice_request(this_arg, message);
12334 return nativeResponseValue;
12337 export class LDKSignError {
12338 protected constructor() {}
12341 export function LDKSignError_ty_from_ptr(ptr: bigint): number {
12342 if(!isWasmInitialized) {
12343 throw new Error("initializeWasm() must be awaited first!");
12345 const nativeResponseValue = wasm.TS_LDKSignError_ty_from_ptr(ptr);
12346 return nativeResponseValue;
12349 export function LDKSignError_Verification_get_verification(ptr: bigint): Secp256k1Error {
12350 if(!isWasmInitialized) {
12351 throw new Error("initializeWasm() must be awaited first!");
12353 const nativeResponseValue = wasm.TS_LDKSignError_Verification_get_verification(ptr);
12354 return nativeResponseValue;
12357 export class LDKEffectiveCapacity {
12358 protected constructor() {}
12361 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
12362 if(!isWasmInitialized) {
12363 throw new Error("initializeWasm() must be awaited first!");
12365 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
12366 return nativeResponseValue;
12369 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
12370 if(!isWasmInitialized) {
12371 throw new Error("initializeWasm() must be awaited first!");
12373 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
12374 return nativeResponseValue;
12377 export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
12378 if(!isWasmInitialized) {
12379 throw new Error("initializeWasm() must be awaited first!");
12381 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
12382 return nativeResponseValue;
12385 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
12386 if(!isWasmInitialized) {
12387 throw new Error("initializeWasm() must be awaited first!");
12389 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
12390 return nativeResponseValue;
12393 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
12394 if(!isWasmInitialized) {
12395 throw new Error("initializeWasm() must be awaited first!");
12397 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
12398 return nativeResponseValue;
12401 export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
12402 if(!isWasmInitialized) {
12403 throw new Error("initializeWasm() must be awaited first!");
12405 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
12406 return nativeResponseValue;
12409 export class LDKPayee {
12410 protected constructor() {}
12413 export function LDKPayee_ty_from_ptr(ptr: bigint): number {
12414 if(!isWasmInitialized) {
12415 throw new Error("initializeWasm() must be awaited first!");
12417 const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
12418 return nativeResponseValue;
12421 export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
12422 if(!isWasmInitialized) {
12423 throw new Error("initializeWasm() must be awaited first!");
12425 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
12426 return nativeResponseValue;
12429 export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
12430 if(!isWasmInitialized) {
12431 throw new Error("initializeWasm() must be awaited first!");
12433 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
12434 return nativeResponseValue;
12437 export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
12438 if(!isWasmInitialized) {
12439 throw new Error("initializeWasm() must be awaited first!");
12441 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
12442 return nativeResponseValue;
12445 export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
12446 if(!isWasmInitialized) {
12447 throw new Error("initializeWasm() must be awaited first!");
12449 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
12450 return nativeResponseValue;
12453 export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
12454 if(!isWasmInitialized) {
12455 throw new Error("initializeWasm() must be awaited first!");
12457 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
12458 return nativeResponseValue;
12461 export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
12462 if(!isWasmInitialized) {
12463 throw new Error("initializeWasm() must be awaited first!");
12465 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
12466 return nativeResponseValue;
12469 export interface LDKScore {
12474 export function LDKScore_new(impl: LDKScore, ScoreLookUp: number, ScoreUpdate: number): [bigint, number] {
12475 if(!isWasmInitialized) {
12476 throw new Error("initializeWasm() must be awaited first!");
12478 var new_obj_idx = js_objs.length;
12479 for (var i = 0; i < js_objs.length; i++) {
12480 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12482 js_objs[i] = new WeakRef(impl);
12483 return [wasm.TS_LDKScore_new(i, ScoreLookUp, ScoreUpdate), i];
12485 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
12487 export function Score_write(this_arg: bigint): number {
12488 if(!isWasmInitialized) {
12489 throw new Error("initializeWasm() must be awaited first!");
12491 const nativeResponseValue = wasm.TS_Score_write(this_arg);
12492 return nativeResponseValue;
12495 export class LDKIntroductionNode {
12496 protected constructor() {}
12499 export function LDKIntroductionNode_ty_from_ptr(ptr: bigint): number {
12500 if(!isWasmInitialized) {
12501 throw new Error("initializeWasm() must be awaited first!");
12503 const nativeResponseValue = wasm.TS_LDKIntroductionNode_ty_from_ptr(ptr);
12504 return nativeResponseValue;
12507 export function LDKIntroductionNode_NodeId_get_node_id(ptr: bigint): number {
12508 if(!isWasmInitialized) {
12509 throw new Error("initializeWasm() must be awaited first!");
12511 const nativeResponseValue = wasm.TS_LDKIntroductionNode_NodeId_get_node_id(ptr);
12512 return nativeResponseValue;
12515 export function LDKIntroductionNode_DirectedShortChannelId_get__0(ptr: bigint): Direction {
12516 if(!isWasmInitialized) {
12517 throw new Error("initializeWasm() must be awaited first!");
12519 const nativeResponseValue = wasm.TS_LDKIntroductionNode_DirectedShortChannelId_get__0(ptr);
12520 return nativeResponseValue;
12523 export function LDKIntroductionNode_DirectedShortChannelId_get__1(ptr: bigint): bigint {
12524 if(!isWasmInitialized) {
12525 throw new Error("initializeWasm() must be awaited first!");
12527 const nativeResponseValue = wasm.TS_LDKIntroductionNode_DirectedShortChannelId_get__1(ptr);
12528 return nativeResponseValue;
12531 export interface LDKCoinSelectionSource {
12532 select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
12533 sign_psbt (psbt: number): bigint;
12537 export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
12538 if(!isWasmInitialized) {
12539 throw new Error("initializeWasm() must be awaited first!");
12541 var new_obj_idx = js_objs.length;
12542 for (var i = 0; i < js_objs.length; i++) {
12543 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12545 js_objs[i] = new WeakRef(impl);
12546 return [wasm.TS_LDKCoinSelectionSource_new(i), i];
12548 // LDKCResult_CoinSelectionNoneZ CoinSelectionSource_select_confirmed_utxos LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight
12550 export function CoinSelectionSource_select_confirmed_utxos(this_arg: bigint, claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint {
12551 if(!isWasmInitialized) {
12552 throw new Error("initializeWasm() must be awaited first!");
12554 const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
12555 return nativeResponseValue;
12557 // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_psbt LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
12559 export function CoinSelectionSource_sign_psbt(this_arg: bigint, psbt: number): bigint {
12560 if(!isWasmInitialized) {
12561 throw new Error("initializeWasm() must be awaited first!");
12563 const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_psbt(this_arg, psbt);
12564 return nativeResponseValue;
12567 export interface LDKWalletSource {
12568 list_confirmed_utxos (): bigint;
12569 get_change_script (): bigint;
12570 sign_psbt (psbt: number): bigint;
12574 export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
12575 if(!isWasmInitialized) {
12576 throw new Error("initializeWasm() must be awaited first!");
12578 var new_obj_idx = js_objs.length;
12579 for (var i = 0; i < js_objs.length; i++) {
12580 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
12582 js_objs[i] = new WeakRef(impl);
12583 return [wasm.TS_LDKWalletSource_new(i), i];
12585 // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
12587 export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
12588 if(!isWasmInitialized) {
12589 throw new Error("initializeWasm() must be awaited first!");
12591 const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
12592 return nativeResponseValue;
12594 // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
12596 export function WalletSource_get_change_script(this_arg: bigint): bigint {
12597 if(!isWasmInitialized) {
12598 throw new Error("initializeWasm() must be awaited first!");
12600 const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
12601 return nativeResponseValue;
12603 // LDKCResult_TransactionNoneZ WalletSource_sign_psbt LDKWalletSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
12605 export function WalletSource_sign_psbt(this_arg: bigint, psbt: number): bigint {
12606 if(!isWasmInitialized) {
12607 throw new Error("initializeWasm() must be awaited first!");
12609 const nativeResponseValue = wasm.TS_WalletSource_sign_psbt(this_arg, psbt);
12610 return nativeResponseValue;
12613 export class LDKGossipSync {
12614 protected constructor() {}
12617 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
12618 if(!isWasmInitialized) {
12619 throw new Error("initializeWasm() must be awaited first!");
12621 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
12622 return nativeResponseValue;
12625 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
12626 if(!isWasmInitialized) {
12627 throw new Error("initializeWasm() must be awaited first!");
12629 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
12630 return nativeResponseValue;
12633 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
12634 if(!isWasmInitialized) {
12635 throw new Error("initializeWasm() must be awaited first!");
12637 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
12638 return nativeResponseValue;
12641 export class LDKFallback {
12642 protected constructor() {}
12645 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
12646 if(!isWasmInitialized) {
12647 throw new Error("initializeWasm() must be awaited first!");
12649 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
12650 return nativeResponseValue;
12653 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
12654 if(!isWasmInitialized) {
12655 throw new Error("initializeWasm() must be awaited first!");
12657 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
12658 return nativeResponseValue;
12661 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
12662 if(!isWasmInitialized) {
12663 throw new Error("initializeWasm() must be awaited first!");
12665 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
12666 return nativeResponseValue;
12669 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
12670 if(!isWasmInitialized) {
12671 throw new Error("initializeWasm() must be awaited first!");
12673 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
12674 return nativeResponseValue;
12677 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
12678 if(!isWasmInitialized) {
12679 throw new Error("initializeWasm() must be awaited first!");
12681 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
12682 return nativeResponseValue;
12684 // struct LDKStr _ldk_get_compiled_version(void);
12686 export function _ldk_get_compiled_version(): number {
12687 if(!isWasmInitialized) {
12688 throw new Error("initializeWasm() must be awaited first!");
12690 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
12691 return nativeResponseValue;
12693 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
12695 export function _ldk_c_bindings_get_compiled_version(): number {
12696 if(!isWasmInitialized) {
12697 throw new Error("initializeWasm() must be awaited first!");
12699 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
12700 return nativeResponseValue;
12702 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
12704 export function U128_le_bytes(val: number): number {
12705 if(!isWasmInitialized) {
12706 throw new Error("initializeWasm() must be awaited first!");
12708 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
12709 return nativeResponseValue;
12711 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
12713 export function U128_new(le_bytes: number): number {
12714 if(!isWasmInitialized) {
12715 throw new Error("initializeWasm() must be awaited first!");
12717 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
12718 return nativeResponseValue;
12720 // struct LDKWitnessProgram WitnessProgram_new(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
12722 export function WitnessProgram_new(version: number, program: number): bigint {
12723 if(!isWasmInitialized) {
12724 throw new Error("initializeWasm() must be awaited first!");
12726 const nativeResponseValue = wasm.TS_WitnessProgram_new(version, program);
12727 return nativeResponseValue;
12729 // struct LDKWitnessVersion WitnessProgram_get_version(const struct LDKWitnessProgram *NONNULL_PTR prog);
12731 export function WitnessProgram_get_version(prog: bigint): number {
12732 if(!isWasmInitialized) {
12733 throw new Error("initializeWasm() must be awaited first!");
12735 const nativeResponseValue = wasm.TS_WitnessProgram_get_version(prog);
12736 return nativeResponseValue;
12738 // struct LDKu8slice WitnessProgram_get_program(const struct LDKWitnessProgram *NONNULL_PTR prog);
12740 export function WitnessProgram_get_program(prog: bigint): number {
12741 if(!isWasmInitialized) {
12742 throw new Error("initializeWasm() must be awaited first!");
12744 const nativeResponseValue = wasm.TS_WitnessProgram_get_program(prog);
12745 return nativeResponseValue;
12747 // uint64_t WitnessProgram_clone_ptr(LDKWitnessProgram *NONNULL_PTR arg);
12749 export function WitnessProgram_clone_ptr(arg: bigint): bigint {
12750 if(!isWasmInitialized) {
12751 throw new Error("initializeWasm() must be awaited first!");
12753 const nativeResponseValue = wasm.TS_WitnessProgram_clone_ptr(arg);
12754 return nativeResponseValue;
12756 // struct LDKWitnessProgram WitnessProgram_clone(const struct LDKWitnessProgram *NONNULL_PTR orig);
12758 export function WitnessProgram_clone(orig: bigint): bigint {
12759 if(!isWasmInitialized) {
12760 throw new Error("initializeWasm() must be awaited first!");
12762 const nativeResponseValue = wasm.TS_WitnessProgram_clone(orig);
12763 return nativeResponseValue;
12765 // void WitnessProgram_free(struct LDKWitnessProgram o);
12767 export function WitnessProgram_free(o: bigint): void {
12768 if(!isWasmInitialized) {
12769 throw new Error("initializeWasm() must be awaited first!");
12771 const nativeResponseValue = wasm.TS_WitnessProgram_free(o);
12772 // debug statements here
12774 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
12776 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
12777 if(!isWasmInitialized) {
12778 throw new Error("initializeWasm() must be awaited first!");
12780 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
12781 return nativeResponseValue;
12783 // uint64_t BigEndianScalar_clone_ptr(LDKBigEndianScalar *NONNULL_PTR arg);
12785 export function BigEndianScalar_clone_ptr(arg: bigint): bigint {
12786 if(!isWasmInitialized) {
12787 throw new Error("initializeWasm() must be awaited first!");
12789 const nativeResponseValue = wasm.TS_BigEndianScalar_clone_ptr(arg);
12790 return nativeResponseValue;
12792 // struct LDKBigEndianScalar BigEndianScalar_clone(const struct LDKBigEndianScalar *NONNULL_PTR orig);
12794 export function BigEndianScalar_clone(orig: bigint): bigint {
12795 if(!isWasmInitialized) {
12796 throw new Error("initializeWasm() must be awaited first!");
12798 const nativeResponseValue = wasm.TS_BigEndianScalar_clone(orig);
12799 return nativeResponseValue;
12801 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
12803 export function Bech32Error_clone_ptr(arg: bigint): bigint {
12804 if(!isWasmInitialized) {
12805 throw new Error("initializeWasm() must be awaited first!");
12807 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
12808 return nativeResponseValue;
12810 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
12812 export function Bech32Error_clone(orig: bigint): bigint {
12813 if(!isWasmInitialized) {
12814 throw new Error("initializeWasm() must be awaited first!");
12816 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
12817 return nativeResponseValue;
12819 // void Bech32Error_free(struct LDKBech32Error o);
12821 export function Bech32Error_free(o: bigint): void {
12822 if(!isWasmInitialized) {
12823 throw new Error("initializeWasm() must be awaited first!");
12825 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
12826 // debug statements here
12828 // void Transaction_free(struct LDKTransaction _res);
12830 export function Transaction_free(_res: number): void {
12831 if(!isWasmInitialized) {
12832 throw new Error("initializeWasm() must be awaited first!");
12834 const nativeResponseValue = wasm.TS_Transaction_free(_res);
12835 // debug statements here
12837 // void Witness_free(struct LDKWitness _res);
12839 export function Witness_free(_res: number): void {
12840 if(!isWasmInitialized) {
12841 throw new Error("initializeWasm() must be awaited first!");
12843 const nativeResponseValue = wasm.TS_Witness_free(_res);
12844 // debug statements here
12846 // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
12848 export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
12849 if(!isWasmInitialized) {
12850 throw new Error("initializeWasm() must be awaited first!");
12852 const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
12853 return nativeResponseValue;
12855 // struct LDKWitness TxIn_get_witness(const struct LDKTxIn *NONNULL_PTR txin);
12857 export function TxIn_get_witness(txin: bigint): number {
12858 if(!isWasmInitialized) {
12859 throw new Error("initializeWasm() must be awaited first!");
12861 const nativeResponseValue = wasm.TS_TxIn_get_witness(txin);
12862 return nativeResponseValue;
12864 // struct LDKu8slice TxIn_get_script_sig(const struct LDKTxIn *NONNULL_PTR txin);
12866 export function TxIn_get_script_sig(txin: bigint): number {
12867 if(!isWasmInitialized) {
12868 throw new Error("initializeWasm() must be awaited first!");
12870 const nativeResponseValue = wasm.TS_TxIn_get_script_sig(txin);
12871 return nativeResponseValue;
12873 // uint32_t TxIn_get_sequence(const struct LDKTxIn *NONNULL_PTR txin);
12875 export function TxIn_get_sequence(txin: bigint): number {
12876 if(!isWasmInitialized) {
12877 throw new Error("initializeWasm() must be awaited first!");
12879 const nativeResponseValue = wasm.TS_TxIn_get_sequence(txin);
12880 return nativeResponseValue;
12882 // struct LDKThirtyTwoBytes TxIn_get_previous_txid(const struct LDKTxIn *NONNULL_PTR txin);
12884 export function TxIn_get_previous_txid(txin: bigint): number {
12885 if(!isWasmInitialized) {
12886 throw new Error("initializeWasm() must be awaited first!");
12888 const nativeResponseValue = wasm.TS_TxIn_get_previous_txid(txin);
12889 return nativeResponseValue;
12891 // uint32_t TxIn_get_previous_vout(const struct LDKTxIn *NONNULL_PTR txin);
12893 export function TxIn_get_previous_vout(txin: bigint): number {
12894 if(!isWasmInitialized) {
12895 throw new Error("initializeWasm() must be awaited first!");
12897 const nativeResponseValue = wasm.TS_TxIn_get_previous_vout(txin);
12898 return nativeResponseValue;
12900 // void TxIn_free(struct LDKTxIn _res);
12902 export function TxIn_free(_res: bigint): void {
12903 if(!isWasmInitialized) {
12904 throw new Error("initializeWasm() must be awaited first!");
12906 const nativeResponseValue = wasm.TS_TxIn_free(_res);
12907 // debug statements here
12909 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
12911 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
12912 if(!isWasmInitialized) {
12913 throw new Error("initializeWasm() must be awaited first!");
12915 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
12916 return nativeResponseValue;
12918 // struct LDKu8slice TxOut_get_script_pubkey(const struct LDKTxOut *NONNULL_PTR txout);
12920 export function TxOut_get_script_pubkey(txout: bigint): number {
12921 if(!isWasmInitialized) {
12922 throw new Error("initializeWasm() must be awaited first!");
12924 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(txout);
12925 return nativeResponseValue;
12927 // uint64_t TxOut_get_value(const struct LDKTxOut *NONNULL_PTR txout);
12929 export function TxOut_get_value(txout: bigint): bigint {
12930 if(!isWasmInitialized) {
12931 throw new Error("initializeWasm() must be awaited first!");
12933 const nativeResponseValue = wasm.TS_TxOut_get_value(txout);
12934 return nativeResponseValue;
12936 // void TxOut_free(struct LDKTxOut _res);
12938 export function TxOut_free(_res: bigint): void {
12939 if(!isWasmInitialized) {
12940 throw new Error("initializeWasm() must be awaited first!");
12942 const nativeResponseValue = wasm.TS_TxOut_free(_res);
12943 // debug statements here
12945 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
12947 export function TxOut_clone_ptr(arg: bigint): bigint {
12948 if(!isWasmInitialized) {
12949 throw new Error("initializeWasm() must be awaited first!");
12951 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
12952 return nativeResponseValue;
12954 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
12956 export function TxOut_clone(orig: bigint): bigint {
12957 if(!isWasmInitialized) {
12958 throw new Error("initializeWasm() must be awaited first!");
12960 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
12961 return nativeResponseValue;
12963 // void Str_free(struct LDKStr _res);
12965 export function Str_free(_res: number): void {
12966 if(!isWasmInitialized) {
12967 throw new Error("initializeWasm() must be awaited first!");
12969 const nativeResponseValue = wasm.TS_Str_free(_res);
12970 // debug statements here
12972 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
12974 export function CVec_u8Z_free(_res: number): void {
12975 if(!isWasmInitialized) {
12976 throw new Error("initializeWasm() must be awaited first!");
12978 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
12979 // debug statements here
12981 // struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(struct LDKRefundMaybeWithDerivedMetadataBuilder o);
12983 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
12984 if(!isWasmInitialized) {
12985 throw new Error("initializeWasm() must be awaited first!");
12987 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(o);
12988 return nativeResponseValue;
12990 // struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
12992 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
12993 if(!isWasmInitialized) {
12994 throw new Error("initializeWasm() must be awaited first!");
12996 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(e);
12997 return nativeResponseValue;
12999 // bool CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
13001 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
13002 if(!isWasmInitialized) {
13003 throw new Error("initializeWasm() must be awaited first!");
13005 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(o);
13006 return nativeResponseValue;
13008 // void CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ _res);
13010 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
13011 if(!isWasmInitialized) {
13012 throw new Error("initializeWasm() must be awaited first!");
13014 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(_res);
13015 // debug statements here
13017 // uint64_t CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR arg);
13019 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
13020 if(!isWasmInitialized) {
13021 throw new Error("initializeWasm() must be awaited first!");
13023 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(arg);
13024 return nativeResponseValue;
13026 // struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(const struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR orig);
13028 export function CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(orig: bigint): bigint {
13029 if(!isWasmInitialized) {
13030 throw new Error("initializeWasm() must be awaited first!");
13032 const nativeResponseValue = wasm.TS_CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(orig);
13033 return nativeResponseValue;
13035 // struct LDKCResult_RefundBolt12SemanticErrorZ CResult_RefundBolt12SemanticErrorZ_ok(struct LDKRefund o);
13037 export function CResult_RefundBolt12SemanticErrorZ_ok(o: bigint): bigint {
13038 if(!isWasmInitialized) {
13039 throw new Error("initializeWasm() must be awaited first!");
13041 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_ok(o);
13042 return nativeResponseValue;
13044 // struct LDKCResult_RefundBolt12SemanticErrorZ CResult_RefundBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
13046 export function CResult_RefundBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
13047 if(!isWasmInitialized) {
13048 throw new Error("initializeWasm() must be awaited first!");
13050 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_err(e);
13051 return nativeResponseValue;
13053 // bool CResult_RefundBolt12SemanticErrorZ_is_ok(const struct LDKCResult_RefundBolt12SemanticErrorZ *NONNULL_PTR o);
13055 export function CResult_RefundBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
13056 if(!isWasmInitialized) {
13057 throw new Error("initializeWasm() must be awaited first!");
13059 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_is_ok(o);
13060 return nativeResponseValue;
13062 // void CResult_RefundBolt12SemanticErrorZ_free(struct LDKCResult_RefundBolt12SemanticErrorZ _res);
13064 export function CResult_RefundBolt12SemanticErrorZ_free(_res: bigint): void {
13065 if(!isWasmInitialized) {
13066 throw new Error("initializeWasm() must be awaited first!");
13068 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_free(_res);
13069 // debug statements here
13071 // uint64_t CResult_RefundBolt12SemanticErrorZ_clone_ptr(LDKCResult_RefundBolt12SemanticErrorZ *NONNULL_PTR arg);
13073 export function CResult_RefundBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
13074 if(!isWasmInitialized) {
13075 throw new Error("initializeWasm() must be awaited first!");
13077 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_clone_ptr(arg);
13078 return nativeResponseValue;
13080 // struct LDKCResult_RefundBolt12SemanticErrorZ CResult_RefundBolt12SemanticErrorZ_clone(const struct LDKCResult_RefundBolt12SemanticErrorZ *NONNULL_PTR orig);
13082 export function CResult_RefundBolt12SemanticErrorZ_clone(orig: bigint): bigint {
13083 if(!isWasmInitialized) {
13084 throw new Error("initializeWasm() must be awaited first!");
13086 const nativeResponseValue = wasm.TS_CResult_RefundBolt12SemanticErrorZ_clone(orig);
13087 return nativeResponseValue;
13089 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
13091 export function COption_u64Z_some(o: bigint): bigint {
13092 if(!isWasmInitialized) {
13093 throw new Error("initializeWasm() must be awaited first!");
13095 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
13096 return nativeResponseValue;
13098 // struct LDKCOption_u64Z COption_u64Z_none(void);
13100 export function COption_u64Z_none(): bigint {
13101 if(!isWasmInitialized) {
13102 throw new Error("initializeWasm() must be awaited first!");
13104 const nativeResponseValue = wasm.TS_COption_u64Z_none();
13105 return nativeResponseValue;
13107 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
13109 export function COption_u64Z_free(_res: bigint): void {
13110 if(!isWasmInitialized) {
13111 throw new Error("initializeWasm() must be awaited first!");
13113 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
13114 // debug statements here
13116 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
13118 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
13119 if(!isWasmInitialized) {
13120 throw new Error("initializeWasm() must be awaited first!");
13122 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
13123 return nativeResponseValue;
13125 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
13127 export function COption_u64Z_clone(orig: bigint): bigint {
13128 if(!isWasmInitialized) {
13129 throw new Error("initializeWasm() must be awaited first!");
13131 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
13132 return nativeResponseValue;
13134 // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
13136 export function CVec_BlindedPathZ_free(_res: number): void {
13137 if(!isWasmInitialized) {
13138 throw new Error("initializeWasm() must be awaited first!");
13140 const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
13141 // debug statements here
13143 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
13145 export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
13146 if(!isWasmInitialized) {
13147 throw new Error("initializeWasm() must be awaited first!");
13149 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
13150 return nativeResponseValue;
13152 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
13154 export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
13155 if(!isWasmInitialized) {
13156 throw new Error("initializeWasm() must be awaited first!");
13158 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
13159 return nativeResponseValue;
13161 // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
13163 export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
13164 if(!isWasmInitialized) {
13165 throw new Error("initializeWasm() must be awaited first!");
13167 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
13168 return nativeResponseValue;
13170 // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
13172 export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
13173 if(!isWasmInitialized) {
13174 throw new Error("initializeWasm() must be awaited first!");
13176 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
13177 // debug statements here
13179 // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
13181 export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
13182 if(!isWasmInitialized) {
13183 throw new Error("initializeWasm() must be awaited first!");
13185 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
13186 return nativeResponseValue;
13188 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
13190 export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
13191 if(!isWasmInitialized) {
13192 throw new Error("initializeWasm() must be awaited first!");
13194 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
13195 return nativeResponseValue;
13197 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
13199 export function CResult_RetryDecodeErrorZ_ok(o: bigint): bigint {
13200 if(!isWasmInitialized) {
13201 throw new Error("initializeWasm() must be awaited first!");
13203 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_ok(o);
13204 return nativeResponseValue;
13206 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
13208 export function CResult_RetryDecodeErrorZ_err(e: bigint): bigint {
13209 if(!isWasmInitialized) {
13210 throw new Error("initializeWasm() must be awaited first!");
13212 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_err(e);
13213 return nativeResponseValue;
13215 // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
13217 export function CResult_RetryDecodeErrorZ_is_ok(o: bigint): boolean {
13218 if(!isWasmInitialized) {
13219 throw new Error("initializeWasm() must be awaited first!");
13221 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_is_ok(o);
13222 return nativeResponseValue;
13224 // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
13226 export function CResult_RetryDecodeErrorZ_free(_res: bigint): void {
13227 if(!isWasmInitialized) {
13228 throw new Error("initializeWasm() must be awaited first!");
13230 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_free(_res);
13231 // debug statements here
13233 // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
13235 export function CResult_RetryDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13236 if(!isWasmInitialized) {
13237 throw new Error("initializeWasm() must be awaited first!");
13239 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone_ptr(arg);
13240 return nativeResponseValue;
13242 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
13244 export function CResult_RetryDecodeErrorZ_clone(orig: bigint): bigint {
13245 if(!isWasmInitialized) {
13246 throw new Error("initializeWasm() must be awaited first!");
13248 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone(orig);
13249 return nativeResponseValue;
13251 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
13253 export function CResult_NoneAPIErrorZ_ok(): bigint {
13254 if(!isWasmInitialized) {
13255 throw new Error("initializeWasm() must be awaited first!");
13257 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
13258 return nativeResponseValue;
13260 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
13262 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
13263 if(!isWasmInitialized) {
13264 throw new Error("initializeWasm() must be awaited first!");
13266 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
13267 return nativeResponseValue;
13269 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
13271 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
13272 if(!isWasmInitialized) {
13273 throw new Error("initializeWasm() must be awaited first!");
13275 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
13276 return nativeResponseValue;
13278 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
13280 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
13281 if(!isWasmInitialized) {
13282 throw new Error("initializeWasm() must be awaited first!");
13284 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
13285 // debug statements here
13287 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
13289 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
13290 if(!isWasmInitialized) {
13291 throw new Error("initializeWasm() must be awaited first!");
13293 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
13294 return nativeResponseValue;
13296 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
13298 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
13299 if(!isWasmInitialized) {
13300 throw new Error("initializeWasm() must be awaited first!");
13302 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
13303 return nativeResponseValue;
13305 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
13307 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
13308 if(!isWasmInitialized) {
13309 throw new Error("initializeWasm() must be awaited first!");
13311 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
13312 // debug statements here
13314 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
13316 export function CVec_APIErrorZ_free(_res: number): void {
13317 if(!isWasmInitialized) {
13318 throw new Error("initializeWasm() must be awaited first!");
13320 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
13321 // debug statements here
13323 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
13325 export function COption_ThirtyTwoBytesZ_some(o: number): bigint {
13326 if(!isWasmInitialized) {
13327 throw new Error("initializeWasm() must be awaited first!");
13329 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_some(o);
13330 return nativeResponseValue;
13332 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
13334 export function COption_ThirtyTwoBytesZ_none(): bigint {
13335 if(!isWasmInitialized) {
13336 throw new Error("initializeWasm() must be awaited first!");
13338 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_none();
13339 return nativeResponseValue;
13341 // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
13343 export function COption_ThirtyTwoBytesZ_free(_res: bigint): void {
13344 if(!isWasmInitialized) {
13345 throw new Error("initializeWasm() must be awaited first!");
13347 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_free(_res);
13348 // debug statements here
13350 // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
13352 export function COption_ThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
13353 if(!isWasmInitialized) {
13354 throw new Error("initializeWasm() must be awaited first!");
13356 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone_ptr(arg);
13357 return nativeResponseValue;
13359 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
13361 export function COption_ThirtyTwoBytesZ_clone(orig: bigint): bigint {
13362 if(!isWasmInitialized) {
13363 throw new Error("initializeWasm() must be awaited first!");
13365 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone(orig);
13366 return nativeResponseValue;
13368 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
13370 export function COption_CVec_u8ZZ_some(o: number): bigint {
13371 if(!isWasmInitialized) {
13372 throw new Error("initializeWasm() must be awaited first!");
13374 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
13375 return nativeResponseValue;
13377 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
13379 export function COption_CVec_u8ZZ_none(): bigint {
13380 if(!isWasmInitialized) {
13381 throw new Error("initializeWasm() must be awaited first!");
13383 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
13384 return nativeResponseValue;
13386 // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
13388 export function COption_CVec_u8ZZ_free(_res: bigint): void {
13389 if(!isWasmInitialized) {
13390 throw new Error("initializeWasm() must be awaited first!");
13392 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
13393 // debug statements here
13395 // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
13397 export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
13398 if(!isWasmInitialized) {
13399 throw new Error("initializeWasm() must be awaited first!");
13401 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
13402 return nativeResponseValue;
13404 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
13406 export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
13407 if(!isWasmInitialized) {
13408 throw new Error("initializeWasm() must be awaited first!");
13410 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
13411 return nativeResponseValue;
13413 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
13415 export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
13416 if(!isWasmInitialized) {
13417 throw new Error("initializeWasm() must be awaited first!");
13419 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
13420 return nativeResponseValue;
13422 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
13424 export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
13425 if(!isWasmInitialized) {
13426 throw new Error("initializeWasm() must be awaited first!");
13428 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
13429 return nativeResponseValue;
13431 // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
13433 export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
13434 if(!isWasmInitialized) {
13435 throw new Error("initializeWasm() must be awaited first!");
13437 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
13438 return nativeResponseValue;
13440 // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
13442 export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
13443 if(!isWasmInitialized) {
13444 throw new Error("initializeWasm() must be awaited first!");
13446 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
13447 // debug statements here
13449 // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
13451 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13452 if(!isWasmInitialized) {
13453 throw new Error("initializeWasm() must be awaited first!");
13455 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
13456 return nativeResponseValue;
13458 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
13460 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
13461 if(!isWasmInitialized) {
13462 throw new Error("initializeWasm() must be awaited first!");
13464 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
13465 return nativeResponseValue;
13467 // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
13469 export function C2Tuple_u64CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
13470 if(!isWasmInitialized) {
13471 throw new Error("initializeWasm() must be awaited first!");
13473 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(arg);
13474 return nativeResponseValue;
13476 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
13478 export function C2Tuple_u64CVec_u8ZZ_clone(orig: bigint): bigint {
13479 if(!isWasmInitialized) {
13480 throw new Error("initializeWasm() must be awaited first!");
13482 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone(orig);
13483 return nativeResponseValue;
13485 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
13487 export function C2Tuple_u64CVec_u8ZZ_new(a: bigint, b: number): bigint {
13488 if(!isWasmInitialized) {
13489 throw new Error("initializeWasm() must be awaited first!");
13491 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_new(a, b);
13492 return nativeResponseValue;
13494 // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
13496 export function C2Tuple_u64CVec_u8ZZ_free(_res: bigint): void {
13497 if(!isWasmInitialized) {
13498 throw new Error("initializeWasm() must be awaited first!");
13500 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_free(_res);
13501 // debug statements here
13503 // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
13505 export function CVec_C2Tuple_u64CVec_u8ZZZ_free(_res: number): void {
13506 if(!isWasmInitialized) {
13507 throw new Error("initializeWasm() must be awaited first!");
13509 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(_res);
13510 // debug statements here
13512 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
13514 export function CResult_RecipientOnionFieldsNoneZ_ok(o: bigint): bigint {
13515 if(!isWasmInitialized) {
13516 throw new Error("initializeWasm() must be awaited first!");
13518 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_ok(o);
13519 return nativeResponseValue;
13521 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
13523 export function CResult_RecipientOnionFieldsNoneZ_err(): bigint {
13524 if(!isWasmInitialized) {
13525 throw new Error("initializeWasm() must be awaited first!");
13527 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_err();
13528 return nativeResponseValue;
13530 // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
13532 export function CResult_RecipientOnionFieldsNoneZ_is_ok(o: bigint): boolean {
13533 if(!isWasmInitialized) {
13534 throw new Error("initializeWasm() must be awaited first!");
13536 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_is_ok(o);
13537 return nativeResponseValue;
13539 // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
13541 export function CResult_RecipientOnionFieldsNoneZ_free(_res: bigint): void {
13542 if(!isWasmInitialized) {
13543 throw new Error("initializeWasm() must be awaited first!");
13545 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_free(_res);
13546 // debug statements here
13548 // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
13550 export function CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg: bigint): bigint {
13551 if(!isWasmInitialized) {
13552 throw new Error("initializeWasm() must be awaited first!");
13554 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg);
13555 return nativeResponseValue;
13557 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
13559 export function CResult_RecipientOnionFieldsNoneZ_clone(orig: bigint): bigint {
13560 if(!isWasmInitialized) {
13561 throw new Error("initializeWasm() must be awaited first!");
13563 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone(orig);
13564 return nativeResponseValue;
13566 // struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_ok(struct LDKUnsignedBolt12Invoice o);
13568 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_ok(o: bigint): bigint {
13569 if(!isWasmInitialized) {
13570 throw new Error("initializeWasm() must be awaited first!");
13572 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_ok(o);
13573 return nativeResponseValue;
13575 // struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
13577 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
13578 if(!isWasmInitialized) {
13579 throw new Error("initializeWasm() must be awaited first!");
13581 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_err(e);
13582 return nativeResponseValue;
13584 // bool CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_is_ok(const struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR o);
13586 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
13587 if(!isWasmInitialized) {
13588 throw new Error("initializeWasm() must be awaited first!");
13590 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_is_ok(o);
13591 return nativeResponseValue;
13593 // void CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ _res);
13595 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(_res: bigint): void {
13596 if(!isWasmInitialized) {
13597 throw new Error("initializeWasm() must be awaited first!");
13599 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(_res);
13600 // debug statements here
13602 // uint64_t CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone_ptr(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR arg);
13604 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
13605 if(!isWasmInitialized) {
13606 throw new Error("initializeWasm() must be awaited first!");
13608 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone_ptr(arg);
13609 return nativeResponseValue;
13611 // struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone(const struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR orig);
13613 export function CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone(orig: bigint): bigint {
13614 if(!isWasmInitialized) {
13615 throw new Error("initializeWasm() must be awaited first!");
13617 const nativeResponseValue = wasm.TS_CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_clone(orig);
13618 return nativeResponseValue;
13620 // struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ CResult_Bolt12InvoiceBolt12SemanticErrorZ_ok(struct LDKBolt12Invoice o);
13622 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_ok(o: bigint): bigint {
13623 if(!isWasmInitialized) {
13624 throw new Error("initializeWasm() must be awaited first!");
13626 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_ok(o);
13627 return nativeResponseValue;
13629 // struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ CResult_Bolt12InvoiceBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
13631 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
13632 if(!isWasmInitialized) {
13633 throw new Error("initializeWasm() must be awaited first!");
13635 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_err(e);
13636 return nativeResponseValue;
13638 // bool CResult_Bolt12InvoiceBolt12SemanticErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR o);
13640 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
13641 if(!isWasmInitialized) {
13642 throw new Error("initializeWasm() must be awaited first!");
13644 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_is_ok(o);
13645 return nativeResponseValue;
13647 // void CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ _res);
13649 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(_res: bigint): void {
13650 if(!isWasmInitialized) {
13651 throw new Error("initializeWasm() must be awaited first!");
13653 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(_res);
13654 // debug statements here
13656 // uint64_t CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR arg);
13658 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
13659 if(!isWasmInitialized) {
13660 throw new Error("initializeWasm() must be awaited first!");
13662 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone_ptr(arg);
13663 return nativeResponseValue;
13665 // struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone(const struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ *NONNULL_PTR orig);
13667 export function CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone(orig: bigint): bigint {
13668 if(!isWasmInitialized) {
13669 throw new Error("initializeWasm() must be awaited first!");
13671 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceBolt12SemanticErrorZ_clone(orig);
13672 return nativeResponseValue;
13674 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
13676 export function CResult_SchnorrSignatureNoneZ_ok(o: number): bigint {
13677 if(!isWasmInitialized) {
13678 throw new Error("initializeWasm() must be awaited first!");
13680 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_ok(o);
13681 return nativeResponseValue;
13683 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
13685 export function CResult_SchnorrSignatureNoneZ_err(): bigint {
13686 if(!isWasmInitialized) {
13687 throw new Error("initializeWasm() must be awaited first!");
13689 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_err();
13690 return nativeResponseValue;
13692 // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
13694 export function CResult_SchnorrSignatureNoneZ_is_ok(o: bigint): boolean {
13695 if(!isWasmInitialized) {
13696 throw new Error("initializeWasm() must be awaited first!");
13698 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_is_ok(o);
13699 return nativeResponseValue;
13701 // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
13703 export function CResult_SchnorrSignatureNoneZ_free(_res: bigint): void {
13704 if(!isWasmInitialized) {
13705 throw new Error("initializeWasm() must be awaited first!");
13707 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_free(_res);
13708 // debug statements here
13710 // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
13712 export function CResult_SchnorrSignatureNoneZ_clone_ptr(arg: bigint): bigint {
13713 if(!isWasmInitialized) {
13714 throw new Error("initializeWasm() must be awaited first!");
13716 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone_ptr(arg);
13717 return nativeResponseValue;
13719 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
13721 export function CResult_SchnorrSignatureNoneZ_clone(orig: bigint): bigint {
13722 if(!isWasmInitialized) {
13723 throw new Error("initializeWasm() must be awaited first!");
13725 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone(orig);
13726 return nativeResponseValue;
13728 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
13730 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
13731 if(!isWasmInitialized) {
13732 throw new Error("initializeWasm() must be awaited first!");
13734 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
13735 // debug statements here
13737 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
13739 export function COption_CVec_ThirtyTwoBytesZZ_some(o: number): bigint {
13740 if(!isWasmInitialized) {
13741 throw new Error("initializeWasm() must be awaited first!");
13743 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_some(o);
13744 return nativeResponseValue;
13746 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
13748 export function COption_CVec_ThirtyTwoBytesZZ_none(): bigint {
13749 if(!isWasmInitialized) {
13750 throw new Error("initializeWasm() must be awaited first!");
13752 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_none();
13753 return nativeResponseValue;
13755 // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
13757 export function COption_CVec_ThirtyTwoBytesZZ_free(_res: bigint): void {
13758 if(!isWasmInitialized) {
13759 throw new Error("initializeWasm() must be awaited first!");
13761 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_free(_res);
13762 // debug statements here
13764 // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
13766 export function COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
13767 if(!isWasmInitialized) {
13768 throw new Error("initializeWasm() must be awaited first!");
13770 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg);
13771 return nativeResponseValue;
13773 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
13775 export function COption_CVec_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
13776 if(!isWasmInitialized) {
13777 throw new Error("initializeWasm() must be awaited first!");
13779 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone(orig);
13780 return nativeResponseValue;
13782 // struct LDKCOption_AmountZ COption_AmountZ_some(struct LDKAmount o);
13784 export function COption_AmountZ_some(o: bigint): bigint {
13785 if(!isWasmInitialized) {
13786 throw new Error("initializeWasm() must be awaited first!");
13788 const nativeResponseValue = wasm.TS_COption_AmountZ_some(o);
13789 return nativeResponseValue;
13791 // struct LDKCOption_AmountZ COption_AmountZ_none(void);
13793 export function COption_AmountZ_none(): bigint {
13794 if(!isWasmInitialized) {
13795 throw new Error("initializeWasm() must be awaited first!");
13797 const nativeResponseValue = wasm.TS_COption_AmountZ_none();
13798 return nativeResponseValue;
13800 // void COption_AmountZ_free(struct LDKCOption_AmountZ _res);
13802 export function COption_AmountZ_free(_res: bigint): void {
13803 if(!isWasmInitialized) {
13804 throw new Error("initializeWasm() must be awaited first!");
13806 const nativeResponseValue = wasm.TS_COption_AmountZ_free(_res);
13807 // debug statements here
13809 // uint64_t COption_AmountZ_clone_ptr(LDKCOption_AmountZ *NONNULL_PTR arg);
13811 export function COption_AmountZ_clone_ptr(arg: bigint): bigint {
13812 if(!isWasmInitialized) {
13813 throw new Error("initializeWasm() must be awaited first!");
13815 const nativeResponseValue = wasm.TS_COption_AmountZ_clone_ptr(arg);
13816 return nativeResponseValue;
13818 // struct LDKCOption_AmountZ COption_AmountZ_clone(const struct LDKCOption_AmountZ *NONNULL_PTR orig);
13820 export function COption_AmountZ_clone(orig: bigint): bigint {
13821 if(!isWasmInitialized) {
13822 throw new Error("initializeWasm() must be awaited first!");
13824 const nativeResponseValue = wasm.TS_COption_AmountZ_clone(orig);
13825 return nativeResponseValue;
13827 // struct LDKCOption_QuantityZ COption_QuantityZ_some(struct LDKQuantity o);
13829 export function COption_QuantityZ_some(o: bigint): bigint {
13830 if(!isWasmInitialized) {
13831 throw new Error("initializeWasm() must be awaited first!");
13833 const nativeResponseValue = wasm.TS_COption_QuantityZ_some(o);
13834 return nativeResponseValue;
13836 // struct LDKCOption_QuantityZ COption_QuantityZ_none(void);
13838 export function COption_QuantityZ_none(): bigint {
13839 if(!isWasmInitialized) {
13840 throw new Error("initializeWasm() must be awaited first!");
13842 const nativeResponseValue = wasm.TS_COption_QuantityZ_none();
13843 return nativeResponseValue;
13845 // void COption_QuantityZ_free(struct LDKCOption_QuantityZ _res);
13847 export function COption_QuantityZ_free(_res: bigint): void {
13848 if(!isWasmInitialized) {
13849 throw new Error("initializeWasm() must be awaited first!");
13851 const nativeResponseValue = wasm.TS_COption_QuantityZ_free(_res);
13852 // debug statements here
13854 // uint64_t COption_QuantityZ_clone_ptr(LDKCOption_QuantityZ *NONNULL_PTR arg);
13856 export function COption_QuantityZ_clone_ptr(arg: bigint): bigint {
13857 if(!isWasmInitialized) {
13858 throw new Error("initializeWasm() must be awaited first!");
13860 const nativeResponseValue = wasm.TS_COption_QuantityZ_clone_ptr(arg);
13861 return nativeResponseValue;
13863 // struct LDKCOption_QuantityZ COption_QuantityZ_clone(const struct LDKCOption_QuantityZ *NONNULL_PTR orig);
13865 export function COption_QuantityZ_clone(orig: bigint): bigint {
13866 if(!isWasmInitialized) {
13867 throw new Error("initializeWasm() must be awaited first!");
13869 const nativeResponseValue = wasm.TS_COption_QuantityZ_clone(orig);
13870 return nativeResponseValue;
13872 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
13874 export function CResult_ThirtyTwoBytesNoneZ_ok(o: number): bigint {
13875 if(!isWasmInitialized) {
13876 throw new Error("initializeWasm() must be awaited first!");
13878 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_ok(o);
13879 return nativeResponseValue;
13881 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
13883 export function CResult_ThirtyTwoBytesNoneZ_err(): bigint {
13884 if(!isWasmInitialized) {
13885 throw new Error("initializeWasm() must be awaited first!");
13887 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_err();
13888 return nativeResponseValue;
13890 // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
13892 export function CResult_ThirtyTwoBytesNoneZ_is_ok(o: bigint): boolean {
13893 if(!isWasmInitialized) {
13894 throw new Error("initializeWasm() must be awaited first!");
13896 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_is_ok(o);
13897 return nativeResponseValue;
13899 // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
13901 export function CResult_ThirtyTwoBytesNoneZ_free(_res: bigint): void {
13902 if(!isWasmInitialized) {
13903 throw new Error("initializeWasm() must be awaited first!");
13905 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_free(_res);
13906 // debug statements here
13908 // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
13910 export function CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg: bigint): bigint {
13911 if(!isWasmInitialized) {
13912 throw new Error("initializeWasm() must be awaited first!");
13914 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg);
13915 return nativeResponseValue;
13917 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
13919 export function CResult_ThirtyTwoBytesNoneZ_clone(orig: bigint): bigint {
13920 if(!isWasmInitialized) {
13921 throw new Error("initializeWasm() must be awaited first!");
13923 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone(orig);
13924 return nativeResponseValue;
13926 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
13928 export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
13929 if(!isWasmInitialized) {
13930 throw new Error("initializeWasm() must be awaited first!");
13932 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
13933 return nativeResponseValue;
13935 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
13937 export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
13938 if(!isWasmInitialized) {
13939 throw new Error("initializeWasm() must be awaited first!");
13941 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
13942 return nativeResponseValue;
13944 // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
13946 export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
13947 if(!isWasmInitialized) {
13948 throw new Error("initializeWasm() must be awaited first!");
13950 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
13951 return nativeResponseValue;
13953 // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
13955 export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
13956 if(!isWasmInitialized) {
13957 throw new Error("initializeWasm() must be awaited first!");
13959 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
13960 // debug statements here
13962 // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
13964 export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13965 if(!isWasmInitialized) {
13966 throw new Error("initializeWasm() must be awaited first!");
13968 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
13969 return nativeResponseValue;
13971 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
13973 export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
13974 if(!isWasmInitialized) {
13975 throw new Error("initializeWasm() must be awaited first!");
13977 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
13978 return nativeResponseValue;
13980 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
13982 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
13983 if(!isWasmInitialized) {
13984 throw new Error("initializeWasm() must be awaited first!");
13986 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
13987 return nativeResponseValue;
13989 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
13991 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
13992 if(!isWasmInitialized) {
13993 throw new Error("initializeWasm() must be awaited first!");
13995 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
13996 return nativeResponseValue;
13998 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
14000 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
14001 if(!isWasmInitialized) {
14002 throw new Error("initializeWasm() must be awaited first!");
14004 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
14005 return nativeResponseValue;
14007 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
14009 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
14010 if(!isWasmInitialized) {
14011 throw new Error("initializeWasm() must be awaited first!");
14013 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
14014 // debug statements here
14016 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
14018 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14019 if(!isWasmInitialized) {
14020 throw new Error("initializeWasm() must be awaited first!");
14022 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
14023 return nativeResponseValue;
14025 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
14027 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
14028 if(!isWasmInitialized) {
14029 throw new Error("initializeWasm() must be awaited first!");
14031 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
14032 return nativeResponseValue;
14034 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
14036 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
14037 if(!isWasmInitialized) {
14038 throw new Error("initializeWasm() must be awaited first!");
14040 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
14041 return nativeResponseValue;
14043 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
14045 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
14046 if(!isWasmInitialized) {
14047 throw new Error("initializeWasm() must be awaited first!");
14049 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
14050 return nativeResponseValue;
14052 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
14054 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
14055 if(!isWasmInitialized) {
14056 throw new Error("initializeWasm() must be awaited first!");
14058 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
14059 return nativeResponseValue;
14061 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
14063 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
14064 if(!isWasmInitialized) {
14065 throw new Error("initializeWasm() must be awaited first!");
14067 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
14068 // debug statements here
14070 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
14072 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14073 if(!isWasmInitialized) {
14074 throw new Error("initializeWasm() must be awaited first!");
14076 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
14077 return nativeResponseValue;
14079 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
14081 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
14082 if(!isWasmInitialized) {
14083 throw new Error("initializeWasm() must be awaited first!");
14085 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
14086 return nativeResponseValue;
14088 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
14090 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
14091 if(!isWasmInitialized) {
14092 throw new Error("initializeWasm() must be awaited first!");
14094 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
14095 return nativeResponseValue;
14097 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
14099 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
14100 if(!isWasmInitialized) {
14101 throw new Error("initializeWasm() must be awaited first!");
14103 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
14104 return nativeResponseValue;
14106 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
14108 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
14109 if(!isWasmInitialized) {
14110 throw new Error("initializeWasm() must be awaited first!");
14112 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
14113 return nativeResponseValue;
14115 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
14117 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
14118 if(!isWasmInitialized) {
14119 throw new Error("initializeWasm() must be awaited first!");
14121 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
14122 // debug statements here
14124 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
14126 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14127 if(!isWasmInitialized) {
14128 throw new Error("initializeWasm() must be awaited first!");
14130 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
14131 return nativeResponseValue;
14133 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
14135 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
14136 if(!isWasmInitialized) {
14137 throw new Error("initializeWasm() must be awaited first!");
14139 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
14140 return nativeResponseValue;
14142 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
14144 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
14145 if(!isWasmInitialized) {
14146 throw new Error("initializeWasm() must be awaited first!");
14148 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
14149 // debug statements here
14151 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
14153 export function CVec_TxOutZ_free(_res: number): void {
14154 if(!isWasmInitialized) {
14155 throw new Error("initializeWasm() must be awaited first!");
14157 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
14158 // debug statements here
14160 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
14162 export function COption_u32Z_some(o: number): bigint {
14163 if(!isWasmInitialized) {
14164 throw new Error("initializeWasm() must be awaited first!");
14166 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
14167 return nativeResponseValue;
14169 // struct LDKCOption_u32Z COption_u32Z_none(void);
14171 export function COption_u32Z_none(): bigint {
14172 if(!isWasmInitialized) {
14173 throw new Error("initializeWasm() must be awaited first!");
14175 const nativeResponseValue = wasm.TS_COption_u32Z_none();
14176 return nativeResponseValue;
14178 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
14180 export function COption_u32Z_free(_res: bigint): void {
14181 if(!isWasmInitialized) {
14182 throw new Error("initializeWasm() must be awaited first!");
14184 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
14185 // debug statements here
14187 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
14189 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
14190 if(!isWasmInitialized) {
14191 throw new Error("initializeWasm() must be awaited first!");
14193 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
14194 return nativeResponseValue;
14196 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
14198 export function COption_u32Z_clone(orig: bigint): bigint {
14199 if(!isWasmInitialized) {
14200 throw new Error("initializeWasm() must be awaited first!");
14202 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
14203 return nativeResponseValue;
14205 // uint64_t C2Tuple_CVec_u8Zu64Z_clone_ptr(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR arg);
14207 export function C2Tuple_CVec_u8Zu64Z_clone_ptr(arg: bigint): bigint {
14208 if(!isWasmInitialized) {
14209 throw new Error("initializeWasm() must be awaited first!");
14211 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_clone_ptr(arg);
14212 return nativeResponseValue;
14214 // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_clone(const struct LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR orig);
14216 export function C2Tuple_CVec_u8Zu64Z_clone(orig: bigint): bigint {
14217 if(!isWasmInitialized) {
14218 throw new Error("initializeWasm() must be awaited first!");
14220 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_clone(orig);
14221 return nativeResponseValue;
14223 // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_new(struct LDKCVec_u8Z a, uint64_t b);
14225 export function C2Tuple_CVec_u8Zu64Z_new(a: number, b: bigint): bigint {
14226 if(!isWasmInitialized) {
14227 throw new Error("initializeWasm() must be awaited first!");
14229 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_new(a, b);
14230 return nativeResponseValue;
14232 // void C2Tuple_CVec_u8Zu64Z_free(struct LDKC2Tuple_CVec_u8Zu64Z _res);
14234 export function C2Tuple_CVec_u8Zu64Z_free(_res: bigint): void {
14235 if(!isWasmInitialized) {
14236 throw new Error("initializeWasm() must be awaited first!");
14238 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_free(_res);
14239 // debug statements here
14241 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(struct LDKC2Tuple_CVec_u8Zu64Z o);
14243 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(o: bigint): bigint {
14244 if(!isWasmInitialized) {
14245 throw new Error("initializeWasm() must be awaited first!");
14247 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(o);
14248 return nativeResponseValue;
14250 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err(void);
14252 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err(): bigint {
14253 if(!isWasmInitialized) {
14254 throw new Error("initializeWasm() must be awaited first!");
14256 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err();
14257 return nativeResponseValue;
14259 // bool CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR o);
14261 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(o: bigint): boolean {
14262 if(!isWasmInitialized) {
14263 throw new Error("initializeWasm() must be awaited first!");
14265 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(o);
14266 return nativeResponseValue;
14268 // void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ _res);
14270 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(_res: bigint): void {
14271 if(!isWasmInitialized) {
14272 throw new Error("initializeWasm() must be awaited first!");
14274 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(_res);
14275 // debug statements here
14277 // uint64_t CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR arg);
14279 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(arg: bigint): bigint {
14280 if(!isWasmInitialized) {
14281 throw new Error("initializeWasm() must be awaited first!");
14283 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(arg);
14284 return nativeResponseValue;
14286 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR orig);
14288 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(orig: bigint): bigint {
14289 if(!isWasmInitialized) {
14290 throw new Error("initializeWasm() must be awaited first!");
14292 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(orig);
14293 return nativeResponseValue;
14295 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
14297 export function CResult_ChannelDerivationParametersDecodeErrorZ_ok(o: bigint): bigint {
14298 if(!isWasmInitialized) {
14299 throw new Error("initializeWasm() must be awaited first!");
14301 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(o);
14302 return nativeResponseValue;
14304 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
14306 export function CResult_ChannelDerivationParametersDecodeErrorZ_err(e: bigint): bigint {
14307 if(!isWasmInitialized) {
14308 throw new Error("initializeWasm() must be awaited first!");
14310 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(e);
14311 return nativeResponseValue;
14313 // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
14315 export function CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o: bigint): boolean {
14316 if(!isWasmInitialized) {
14317 throw new Error("initializeWasm() must be awaited first!");
14319 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o);
14320 return nativeResponseValue;
14322 // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
14324 export function CResult_ChannelDerivationParametersDecodeErrorZ_free(_res: bigint): void {
14325 if(!isWasmInitialized) {
14326 throw new Error("initializeWasm() must be awaited first!");
14328 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(_res);
14329 // debug statements here
14331 // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
14333 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14334 if(!isWasmInitialized) {
14335 throw new Error("initializeWasm() must be awaited first!");
14337 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg);
14338 return nativeResponseValue;
14340 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
14342 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig: bigint): bigint {
14343 if(!isWasmInitialized) {
14344 throw new Error("initializeWasm() must be awaited first!");
14346 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig);
14347 return nativeResponseValue;
14349 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
14351 export function CResult_HTLCDescriptorDecodeErrorZ_ok(o: bigint): bigint {
14352 if(!isWasmInitialized) {
14353 throw new Error("initializeWasm() must be awaited first!");
14355 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_ok(o);
14356 return nativeResponseValue;
14358 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
14360 export function CResult_HTLCDescriptorDecodeErrorZ_err(e: bigint): bigint {
14361 if(!isWasmInitialized) {
14362 throw new Error("initializeWasm() must be awaited first!");
14364 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_err(e);
14365 return nativeResponseValue;
14367 // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
14369 export function CResult_HTLCDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
14370 if(!isWasmInitialized) {
14371 throw new Error("initializeWasm() must be awaited first!");
14373 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(o);
14374 return nativeResponseValue;
14376 // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
14378 export function CResult_HTLCDescriptorDecodeErrorZ_free(_res: bigint): void {
14379 if(!isWasmInitialized) {
14380 throw new Error("initializeWasm() must be awaited first!");
14382 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_free(_res);
14383 // debug statements here
14385 // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
14387 export function CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14388 if(!isWasmInitialized) {
14389 throw new Error("initializeWasm() must be awaited first!");
14391 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg);
14392 return nativeResponseValue;
14394 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
14396 export function CResult_HTLCDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
14397 if(!isWasmInitialized) {
14398 throw new Error("initializeWasm() must be awaited first!");
14400 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone(orig);
14401 return nativeResponseValue;
14403 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
14405 export function CResult_NoneNoneZ_ok(): bigint {
14406 if(!isWasmInitialized) {
14407 throw new Error("initializeWasm() must be awaited first!");
14409 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
14410 return nativeResponseValue;
14412 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
14414 export function CResult_NoneNoneZ_err(): bigint {
14415 if(!isWasmInitialized) {
14416 throw new Error("initializeWasm() must be awaited first!");
14418 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
14419 return nativeResponseValue;
14421 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
14423 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
14424 if(!isWasmInitialized) {
14425 throw new Error("initializeWasm() must be awaited first!");
14427 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
14428 return nativeResponseValue;
14430 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
14432 export function CResult_NoneNoneZ_free(_res: bigint): void {
14433 if(!isWasmInitialized) {
14434 throw new Error("initializeWasm() must be awaited first!");
14436 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
14437 // debug statements here
14439 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
14441 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
14442 if(!isWasmInitialized) {
14443 throw new Error("initializeWasm() must be awaited first!");
14445 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
14446 return nativeResponseValue;
14448 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
14450 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
14451 if(!isWasmInitialized) {
14452 throw new Error("initializeWasm() must be awaited first!");
14454 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
14455 return nativeResponseValue;
14457 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
14459 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
14460 if(!isWasmInitialized) {
14461 throw new Error("initializeWasm() must be awaited first!");
14463 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
14464 return nativeResponseValue;
14466 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
14468 export function CResult_PublicKeyNoneZ_err(): bigint {
14469 if(!isWasmInitialized) {
14470 throw new Error("initializeWasm() must be awaited first!");
14472 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
14473 return nativeResponseValue;
14475 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
14477 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
14478 if(!isWasmInitialized) {
14479 throw new Error("initializeWasm() must be awaited first!");
14481 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
14482 return nativeResponseValue;
14484 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
14486 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
14487 if(!isWasmInitialized) {
14488 throw new Error("initializeWasm() must be awaited first!");
14490 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
14491 // debug statements here
14493 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
14495 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
14496 if(!isWasmInitialized) {
14497 throw new Error("initializeWasm() must be awaited first!");
14499 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
14500 return nativeResponseValue;
14502 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
14504 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
14505 if(!isWasmInitialized) {
14506 throw new Error("initializeWasm() must be awaited first!");
14508 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
14509 return nativeResponseValue;
14511 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
14513 export function COption_BigEndianScalarZ_some(o: bigint): bigint {
14514 if(!isWasmInitialized) {
14515 throw new Error("initializeWasm() must be awaited first!");
14517 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_some(o);
14518 return nativeResponseValue;
14520 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
14522 export function COption_BigEndianScalarZ_none(): bigint {
14523 if(!isWasmInitialized) {
14524 throw new Error("initializeWasm() must be awaited first!");
14526 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_none();
14527 return nativeResponseValue;
14529 // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
14531 export function COption_BigEndianScalarZ_free(_res: bigint): void {
14532 if(!isWasmInitialized) {
14533 throw new Error("initializeWasm() must be awaited first!");
14535 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_free(_res);
14536 // debug statements here
14538 // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
14540 export function COption_BigEndianScalarZ_clone_ptr(arg: bigint): bigint {
14541 if(!isWasmInitialized) {
14542 throw new Error("initializeWasm() must be awaited first!");
14544 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone_ptr(arg);
14545 return nativeResponseValue;
14547 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
14549 export function COption_BigEndianScalarZ_clone(orig: bigint): bigint {
14550 if(!isWasmInitialized) {
14551 throw new Error("initializeWasm() must be awaited first!");
14553 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone(orig);
14554 return nativeResponseValue;
14556 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
14558 export function CVec_U5Z_free(_res: number): void {
14559 if(!isWasmInitialized) {
14560 throw new Error("initializeWasm() must be awaited first!");
14562 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
14563 // debug statements here
14565 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
14567 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
14568 if(!isWasmInitialized) {
14569 throw new Error("initializeWasm() must be awaited first!");
14571 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
14572 return nativeResponseValue;
14574 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
14576 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
14577 if(!isWasmInitialized) {
14578 throw new Error("initializeWasm() must be awaited first!");
14580 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
14581 return nativeResponseValue;
14583 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
14585 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
14586 if(!isWasmInitialized) {
14587 throw new Error("initializeWasm() must be awaited first!");
14589 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
14590 return nativeResponseValue;
14592 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
14594 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
14595 if(!isWasmInitialized) {
14596 throw new Error("initializeWasm() must be awaited first!");
14598 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
14599 // debug statements here
14601 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
14603 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
14604 if(!isWasmInitialized) {
14605 throw new Error("initializeWasm() must be awaited first!");
14607 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
14608 return nativeResponseValue;
14610 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
14612 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
14613 if(!isWasmInitialized) {
14614 throw new Error("initializeWasm() must be awaited first!");
14616 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
14617 return nativeResponseValue;
14619 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
14621 export function CResult_ECDSASignatureNoneZ_ok(o: number): bigint {
14622 if(!isWasmInitialized) {
14623 throw new Error("initializeWasm() must be awaited first!");
14625 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_ok(o);
14626 return nativeResponseValue;
14628 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
14630 export function CResult_ECDSASignatureNoneZ_err(): bigint {
14631 if(!isWasmInitialized) {
14632 throw new Error("initializeWasm() must be awaited first!");
14634 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_err();
14635 return nativeResponseValue;
14637 // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
14639 export function CResult_ECDSASignatureNoneZ_is_ok(o: bigint): boolean {
14640 if(!isWasmInitialized) {
14641 throw new Error("initializeWasm() must be awaited first!");
14643 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_is_ok(o);
14644 return nativeResponseValue;
14646 // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
14648 export function CResult_ECDSASignatureNoneZ_free(_res: bigint): void {
14649 if(!isWasmInitialized) {
14650 throw new Error("initializeWasm() must be awaited first!");
14652 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_free(_res);
14653 // debug statements here
14655 // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
14657 export function CResult_ECDSASignatureNoneZ_clone_ptr(arg: bigint): bigint {
14658 if(!isWasmInitialized) {
14659 throw new Error("initializeWasm() must be awaited first!");
14661 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone_ptr(arg);
14662 return nativeResponseValue;
14664 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
14666 export function CResult_ECDSASignatureNoneZ_clone(orig: bigint): bigint {
14667 if(!isWasmInitialized) {
14668 throw new Error("initializeWasm() must be awaited first!");
14670 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone(orig);
14671 return nativeResponseValue;
14673 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
14675 export function CResult_TransactionNoneZ_ok(o: number): bigint {
14676 if(!isWasmInitialized) {
14677 throw new Error("initializeWasm() must be awaited first!");
14679 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
14680 return nativeResponseValue;
14682 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
14684 export function CResult_TransactionNoneZ_err(): bigint {
14685 if(!isWasmInitialized) {
14686 throw new Error("initializeWasm() must be awaited first!");
14688 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
14689 return nativeResponseValue;
14691 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
14693 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
14694 if(!isWasmInitialized) {
14695 throw new Error("initializeWasm() must be awaited first!");
14697 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
14698 return nativeResponseValue;
14700 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
14702 export function CResult_TransactionNoneZ_free(_res: bigint): void {
14703 if(!isWasmInitialized) {
14704 throw new Error("initializeWasm() must be awaited first!");
14706 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
14707 // debug statements here
14709 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
14711 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
14712 if(!isWasmInitialized) {
14713 throw new Error("initializeWasm() must be awaited first!");
14715 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
14716 return nativeResponseValue;
14718 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
14720 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
14721 if(!isWasmInitialized) {
14722 throw new Error("initializeWasm() must be awaited first!");
14724 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
14725 return nativeResponseValue;
14727 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
14729 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
14730 if(!isWasmInitialized) {
14731 throw new Error("initializeWasm() must be awaited first!");
14733 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
14734 return nativeResponseValue;
14736 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
14738 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
14739 if(!isWasmInitialized) {
14740 throw new Error("initializeWasm() must be awaited first!");
14742 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
14743 return nativeResponseValue;
14745 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
14747 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
14748 if(!isWasmInitialized) {
14749 throw new Error("initializeWasm() must be awaited first!");
14751 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
14752 return nativeResponseValue;
14754 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
14756 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
14757 if(!isWasmInitialized) {
14758 throw new Error("initializeWasm() must be awaited first!");
14760 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
14761 // debug statements here
14763 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
14765 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14766 if(!isWasmInitialized) {
14767 throw new Error("initializeWasm() must be awaited first!");
14769 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
14770 return nativeResponseValue;
14772 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
14774 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
14775 if(!isWasmInitialized) {
14776 throw new Error("initializeWasm() must be awaited first!");
14778 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
14779 return nativeResponseValue;
14781 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
14783 export function CResult_CVec_u8ZNoneZ_ok(o: number): bigint {
14784 if(!isWasmInitialized) {
14785 throw new Error("initializeWasm() must be awaited first!");
14787 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_ok(o);
14788 return nativeResponseValue;
14790 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
14792 export function CResult_CVec_u8ZNoneZ_err(): bigint {
14793 if(!isWasmInitialized) {
14794 throw new Error("initializeWasm() must be awaited first!");
14796 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_err();
14797 return nativeResponseValue;
14799 // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
14801 export function CResult_CVec_u8ZNoneZ_is_ok(o: bigint): boolean {
14802 if(!isWasmInitialized) {
14803 throw new Error("initializeWasm() must be awaited first!");
14805 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_is_ok(o);
14806 return nativeResponseValue;
14808 // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
14810 export function CResult_CVec_u8ZNoneZ_free(_res: bigint): void {
14811 if(!isWasmInitialized) {
14812 throw new Error("initializeWasm() must be awaited first!");
14814 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_free(_res);
14815 // debug statements here
14817 // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
14819 export function CResult_CVec_u8ZNoneZ_clone_ptr(arg: bigint): bigint {
14820 if(!isWasmInitialized) {
14821 throw new Error("initializeWasm() must be awaited first!");
14823 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone_ptr(arg);
14824 return nativeResponseValue;
14826 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
14828 export function CResult_CVec_u8ZNoneZ_clone(orig: bigint): bigint {
14829 if(!isWasmInitialized) {
14830 throw new Error("initializeWasm() must be awaited first!");
14832 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone(orig);
14833 return nativeResponseValue;
14835 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
14837 export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
14838 if(!isWasmInitialized) {
14839 throw new Error("initializeWasm() must be awaited first!");
14841 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
14842 return nativeResponseValue;
14844 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
14846 export function CResult_ShutdownScriptNoneZ_err(): bigint {
14847 if(!isWasmInitialized) {
14848 throw new Error("initializeWasm() must be awaited first!");
14850 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
14851 return nativeResponseValue;
14853 // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
14855 export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
14856 if(!isWasmInitialized) {
14857 throw new Error("initializeWasm() must be awaited first!");
14859 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
14860 return nativeResponseValue;
14862 // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
14864 export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
14865 if(!isWasmInitialized) {
14866 throw new Error("initializeWasm() must be awaited first!");
14868 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
14869 // debug statements here
14871 // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
14873 export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
14874 if(!isWasmInitialized) {
14875 throw new Error("initializeWasm() must be awaited first!");
14877 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
14878 return nativeResponseValue;
14880 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
14882 export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
14883 if(!isWasmInitialized) {
14884 throw new Error("initializeWasm() must be awaited first!");
14886 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
14887 return nativeResponseValue;
14889 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
14891 export function COption_u16Z_some(o: number): bigint {
14892 if(!isWasmInitialized) {
14893 throw new Error("initializeWasm() must be awaited first!");
14895 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
14896 return nativeResponseValue;
14898 // struct LDKCOption_u16Z COption_u16Z_none(void);
14900 export function COption_u16Z_none(): bigint {
14901 if(!isWasmInitialized) {
14902 throw new Error("initializeWasm() must be awaited first!");
14904 const nativeResponseValue = wasm.TS_COption_u16Z_none();
14905 return nativeResponseValue;
14907 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
14909 export function COption_u16Z_free(_res: bigint): void {
14910 if(!isWasmInitialized) {
14911 throw new Error("initializeWasm() must be awaited first!");
14913 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
14914 // debug statements here
14916 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
14918 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
14919 if(!isWasmInitialized) {
14920 throw new Error("initializeWasm() must be awaited first!");
14922 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
14923 return nativeResponseValue;
14925 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
14927 export function COption_u16Z_clone(orig: bigint): bigint {
14928 if(!isWasmInitialized) {
14929 throw new Error("initializeWasm() must be awaited first!");
14931 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
14932 return nativeResponseValue;
14934 // struct LDKCOption_boolZ COption_boolZ_some(bool o);
14936 export function COption_boolZ_some(o: boolean): bigint {
14937 if(!isWasmInitialized) {
14938 throw new Error("initializeWasm() must be awaited first!");
14940 const nativeResponseValue = wasm.TS_COption_boolZ_some(o);
14941 return nativeResponseValue;
14943 // struct LDKCOption_boolZ COption_boolZ_none(void);
14945 export function COption_boolZ_none(): bigint {
14946 if(!isWasmInitialized) {
14947 throw new Error("initializeWasm() must be awaited first!");
14949 const nativeResponseValue = wasm.TS_COption_boolZ_none();
14950 return nativeResponseValue;
14952 // void COption_boolZ_free(struct LDKCOption_boolZ _res);
14954 export function COption_boolZ_free(_res: bigint): void {
14955 if(!isWasmInitialized) {
14956 throw new Error("initializeWasm() must be awaited first!");
14958 const nativeResponseValue = wasm.TS_COption_boolZ_free(_res);
14959 // debug statements here
14961 // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
14963 export function COption_boolZ_clone_ptr(arg: bigint): bigint {
14964 if(!isWasmInitialized) {
14965 throw new Error("initializeWasm() must be awaited first!");
14967 const nativeResponseValue = wasm.TS_COption_boolZ_clone_ptr(arg);
14968 return nativeResponseValue;
14970 // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
14972 export function COption_boolZ_clone(orig: bigint): bigint {
14973 if(!isWasmInitialized) {
14974 throw new Error("initializeWasm() must be awaited first!");
14976 const nativeResponseValue = wasm.TS_COption_boolZ_clone(orig);
14977 return nativeResponseValue;
14979 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_ok(struct LDKWitness o);
14981 export function CResult_WitnessNoneZ_ok(o: number): bigint {
14982 if(!isWasmInitialized) {
14983 throw new Error("initializeWasm() must be awaited first!");
14985 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_ok(o);
14986 return nativeResponseValue;
14988 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_err(void);
14990 export function CResult_WitnessNoneZ_err(): bigint {
14991 if(!isWasmInitialized) {
14992 throw new Error("initializeWasm() must be awaited first!");
14994 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_err();
14995 return nativeResponseValue;
14997 // bool CResult_WitnessNoneZ_is_ok(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR o);
14999 export function CResult_WitnessNoneZ_is_ok(o: bigint): boolean {
15000 if(!isWasmInitialized) {
15001 throw new Error("initializeWasm() must be awaited first!");
15003 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_is_ok(o);
15004 return nativeResponseValue;
15006 // void CResult_WitnessNoneZ_free(struct LDKCResult_WitnessNoneZ _res);
15008 export function CResult_WitnessNoneZ_free(_res: bigint): void {
15009 if(!isWasmInitialized) {
15010 throw new Error("initializeWasm() must be awaited first!");
15012 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_free(_res);
15013 // debug statements here
15015 // uint64_t CResult_WitnessNoneZ_clone_ptr(LDKCResult_WitnessNoneZ *NONNULL_PTR arg);
15017 export function CResult_WitnessNoneZ_clone_ptr(arg: bigint): bigint {
15018 if(!isWasmInitialized) {
15019 throw new Error("initializeWasm() must be awaited first!");
15021 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_clone_ptr(arg);
15022 return nativeResponseValue;
15024 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_clone(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR orig);
15026 export function CResult_WitnessNoneZ_clone(orig: bigint): bigint {
15027 if(!isWasmInitialized) {
15028 throw new Error("initializeWasm() must be awaited first!");
15030 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_clone(orig);
15031 return nativeResponseValue;
15033 // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
15035 export function CVec_ECDSASignatureZ_free(_res: number): void {
15036 if(!isWasmInitialized) {
15037 throw new Error("initializeWasm() must be awaited first!");
15039 const nativeResponseValue = wasm.TS_CVec_ECDSASignatureZ_free(_res);
15040 // debug statements here
15042 // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
15044 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg: bigint): bigint {
15045 if(!isWasmInitialized) {
15046 throw new Error("initializeWasm() must be awaited first!");
15048 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg);
15049 return nativeResponseValue;
15051 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
15053 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig: bigint): bigint {
15054 if(!isWasmInitialized) {
15055 throw new Error("initializeWasm() must be awaited first!");
15057 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig);
15058 return nativeResponseValue;
15060 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
15062 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a: number, b: number): bigint {
15063 if(!isWasmInitialized) {
15064 throw new Error("initializeWasm() must be awaited first!");
15066 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a, b);
15067 return nativeResponseValue;
15069 // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
15071 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res: bigint): void {
15072 if(!isWasmInitialized) {
15073 throw new Error("initializeWasm() must be awaited first!");
15075 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res);
15076 // debug statements here
15078 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
15080 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o: bigint): bigint {
15081 if(!isWasmInitialized) {
15082 throw new Error("initializeWasm() must be awaited first!");
15084 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o);
15085 return nativeResponseValue;
15087 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
15089 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(): bigint {
15090 if(!isWasmInitialized) {
15091 throw new Error("initializeWasm() must be awaited first!");
15093 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
15094 return nativeResponseValue;
15096 // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
15098 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o: bigint): boolean {
15099 if(!isWasmInitialized) {
15100 throw new Error("initializeWasm() must be awaited first!");
15102 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o);
15103 return nativeResponseValue;
15105 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
15107 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res: bigint): void {
15108 if(!isWasmInitialized) {
15109 throw new Error("initializeWasm() must be awaited first!");
15111 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res);
15112 // debug statements here
15114 // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
15116 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
15117 if(!isWasmInitialized) {
15118 throw new Error("initializeWasm() must be awaited first!");
15120 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg);
15121 return nativeResponseValue;
15123 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
15125 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig: bigint): bigint {
15126 if(!isWasmInitialized) {
15127 throw new Error("initializeWasm() must be awaited first!");
15129 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig);
15130 return nativeResponseValue;
15132 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
15134 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
15135 if(!isWasmInitialized) {
15136 throw new Error("initializeWasm() must be awaited first!");
15138 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
15139 return nativeResponseValue;
15141 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
15143 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
15144 if(!isWasmInitialized) {
15145 throw new Error("initializeWasm() must be awaited first!");
15147 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
15148 return nativeResponseValue;
15150 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
15152 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
15153 if(!isWasmInitialized) {
15154 throw new Error("initializeWasm() must be awaited first!");
15156 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
15157 return nativeResponseValue;
15159 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
15161 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
15162 if(!isWasmInitialized) {
15163 throw new Error("initializeWasm() must be awaited first!");
15165 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
15166 // debug statements here
15168 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
15170 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15171 if(!isWasmInitialized) {
15172 throw new Error("initializeWasm() must be awaited first!");
15174 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
15175 return nativeResponseValue;
15177 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
15179 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
15180 if(!isWasmInitialized) {
15181 throw new Error("initializeWasm() must be awaited first!");
15183 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
15184 return nativeResponseValue;
15186 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
15188 export function CVec_ChannelDetailsZ_free(_res: number): void {
15189 if(!isWasmInitialized) {
15190 throw new Error("initializeWasm() must be awaited first!");
15192 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
15193 // debug statements here
15195 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
15197 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
15198 if(!isWasmInitialized) {
15199 throw new Error("initializeWasm() must be awaited first!");
15201 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
15202 return nativeResponseValue;
15204 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
15206 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
15207 if(!isWasmInitialized) {
15208 throw new Error("initializeWasm() must be awaited first!");
15210 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
15211 return nativeResponseValue;
15213 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
15215 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
15216 if(!isWasmInitialized) {
15217 throw new Error("initializeWasm() must be awaited first!");
15219 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
15220 return nativeResponseValue;
15222 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
15224 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
15225 if(!isWasmInitialized) {
15226 throw new Error("initializeWasm() must be awaited first!");
15228 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
15229 // debug statements here
15231 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
15233 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
15234 if(!isWasmInitialized) {
15235 throw new Error("initializeWasm() must be awaited first!");
15237 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
15238 return nativeResponseValue;
15240 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
15242 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
15243 if(!isWasmInitialized) {
15244 throw new Error("initializeWasm() must be awaited first!");
15246 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
15247 return nativeResponseValue;
15249 // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
15251 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
15252 if(!isWasmInitialized) {
15253 throw new Error("initializeWasm() must be awaited first!");
15255 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
15256 return nativeResponseValue;
15258 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
15260 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
15261 if(!isWasmInitialized) {
15262 throw new Error("initializeWasm() must be awaited first!");
15264 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
15265 return nativeResponseValue;
15267 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
15269 export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
15270 if(!isWasmInitialized) {
15271 throw new Error("initializeWasm() must be awaited first!");
15273 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
15274 return nativeResponseValue;
15276 // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
15278 export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
15279 if(!isWasmInitialized) {
15280 throw new Error("initializeWasm() must be awaited first!");
15282 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
15283 // debug statements here
15285 // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
15287 export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
15288 if(!isWasmInitialized) {
15289 throw new Error("initializeWasm() must be awaited first!");
15291 const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
15292 // debug statements here
15294 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ o);
15296 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(o: number): bigint {
15297 if(!isWasmInitialized) {
15298 throw new Error("initializeWasm() must be awaited first!");
15300 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(o);
15301 return nativeResponseValue;
15303 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err(void);
15305 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err(): bigint {
15306 if(!isWasmInitialized) {
15307 throw new Error("initializeWasm() must be awaited first!");
15309 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err();
15310 return nativeResponseValue;
15312 // bool CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR o);
15314 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(o: bigint): boolean {
15315 if(!isWasmInitialized) {
15316 throw new Error("initializeWasm() must be awaited first!");
15318 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(o);
15319 return nativeResponseValue;
15321 // void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ _res);
15323 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(_res: bigint): void {
15324 if(!isWasmInitialized) {
15325 throw new Error("initializeWasm() must be awaited first!");
15327 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(_res);
15328 // debug statements here
15330 // uint64_t CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR arg);
15332 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(arg: bigint): bigint {
15333 if(!isWasmInitialized) {
15334 throw new Error("initializeWasm() must be awaited first!");
15336 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(arg);
15337 return nativeResponseValue;
15339 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR orig);
15341 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(orig: bigint): bigint {
15342 if(!isWasmInitialized) {
15343 throw new Error("initializeWasm() must be awaited first!");
15345 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(orig);
15346 return nativeResponseValue;
15348 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
15350 export function CVec_PublicKeyZ_free(_res: number): void {
15351 if(!isWasmInitialized) {
15352 throw new Error("initializeWasm() must be awaited first!");
15354 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
15355 // debug statements here
15357 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
15359 export function CResult_OnionMessagePathNoneZ_ok(o: bigint): bigint {
15360 if(!isWasmInitialized) {
15361 throw new Error("initializeWasm() must be awaited first!");
15363 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_ok(o);
15364 return nativeResponseValue;
15366 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
15368 export function CResult_OnionMessagePathNoneZ_err(): bigint {
15369 if(!isWasmInitialized) {
15370 throw new Error("initializeWasm() must be awaited first!");
15372 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_err();
15373 return nativeResponseValue;
15375 // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
15377 export function CResult_OnionMessagePathNoneZ_is_ok(o: bigint): boolean {
15378 if(!isWasmInitialized) {
15379 throw new Error("initializeWasm() must be awaited first!");
15381 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_is_ok(o);
15382 return nativeResponseValue;
15384 // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
15386 export function CResult_OnionMessagePathNoneZ_free(_res: bigint): void {
15387 if(!isWasmInitialized) {
15388 throw new Error("initializeWasm() must be awaited first!");
15390 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_free(_res);
15391 // debug statements here
15393 // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
15395 export function CResult_OnionMessagePathNoneZ_clone_ptr(arg: bigint): bigint {
15396 if(!isWasmInitialized) {
15397 throw new Error("initializeWasm() must be awaited first!");
15399 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone_ptr(arg);
15400 return nativeResponseValue;
15402 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
15404 export function CResult_OnionMessagePathNoneZ_clone(orig: bigint): bigint {
15405 if(!isWasmInitialized) {
15406 throw new Error("initializeWasm() must be awaited first!");
15408 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone(orig);
15409 return nativeResponseValue;
15411 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_ok(struct LDKCVec_BlindedPathZ o);
15413 export function CResult_CVec_BlindedPathZNoneZ_ok(o: number): bigint {
15414 if(!isWasmInitialized) {
15415 throw new Error("initializeWasm() must be awaited first!");
15417 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_ok(o);
15418 return nativeResponseValue;
15420 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_err(void);
15422 export function CResult_CVec_BlindedPathZNoneZ_err(): bigint {
15423 if(!isWasmInitialized) {
15424 throw new Error("initializeWasm() must be awaited first!");
15426 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_err();
15427 return nativeResponseValue;
15429 // bool CResult_CVec_BlindedPathZNoneZ_is_ok(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR o);
15431 export function CResult_CVec_BlindedPathZNoneZ_is_ok(o: bigint): boolean {
15432 if(!isWasmInitialized) {
15433 throw new Error("initializeWasm() must be awaited first!");
15435 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_is_ok(o);
15436 return nativeResponseValue;
15438 // void CResult_CVec_BlindedPathZNoneZ_free(struct LDKCResult_CVec_BlindedPathZNoneZ _res);
15440 export function CResult_CVec_BlindedPathZNoneZ_free(_res: bigint): void {
15441 if(!isWasmInitialized) {
15442 throw new Error("initializeWasm() must be awaited first!");
15444 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_free(_res);
15445 // debug statements here
15447 // uint64_t CResult_CVec_BlindedPathZNoneZ_clone_ptr(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR arg);
15449 export function CResult_CVec_BlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
15450 if(!isWasmInitialized) {
15451 throw new Error("initializeWasm() must be awaited first!");
15453 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_clone_ptr(arg);
15454 return nativeResponseValue;
15456 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_clone(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR orig);
15458 export function CResult_CVec_BlindedPathZNoneZ_clone(orig: bigint): bigint {
15459 if(!isWasmInitialized) {
15460 throw new Error("initializeWasm() must be awaited first!");
15462 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_clone(orig);
15463 return nativeResponseValue;
15465 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
15467 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
15468 if(!isWasmInitialized) {
15469 throw new Error("initializeWasm() must be awaited first!");
15471 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
15472 return nativeResponseValue;
15474 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
15476 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
15477 if(!isWasmInitialized) {
15478 throw new Error("initializeWasm() must be awaited first!");
15480 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
15481 return nativeResponseValue;
15483 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
15485 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
15486 if(!isWasmInitialized) {
15487 throw new Error("initializeWasm() must be awaited first!");
15489 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
15490 return nativeResponseValue;
15492 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
15494 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
15495 if(!isWasmInitialized) {
15496 throw new Error("initializeWasm() must be awaited first!");
15498 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
15499 // debug statements here
15501 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
15503 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15504 if(!isWasmInitialized) {
15505 throw new Error("initializeWasm() must be awaited first!");
15507 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
15508 return nativeResponseValue;
15510 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
15512 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
15513 if(!isWasmInitialized) {
15514 throw new Error("initializeWasm() must be awaited first!");
15516 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
15517 return nativeResponseValue;
15519 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
15521 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
15522 if(!isWasmInitialized) {
15523 throw new Error("initializeWasm() must be awaited first!");
15525 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
15526 return nativeResponseValue;
15528 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
15530 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
15531 if(!isWasmInitialized) {
15532 throw new Error("initializeWasm() must be awaited first!");
15534 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
15535 return nativeResponseValue;
15537 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
15539 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
15540 if(!isWasmInitialized) {
15541 throw new Error("initializeWasm() must be awaited first!");
15543 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
15544 return nativeResponseValue;
15546 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
15548 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
15549 if(!isWasmInitialized) {
15550 throw new Error("initializeWasm() must be awaited first!");
15552 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
15553 // debug statements here
15555 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
15557 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15558 if(!isWasmInitialized) {
15559 throw new Error("initializeWasm() must be awaited first!");
15561 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
15562 return nativeResponseValue;
15564 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
15566 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
15567 if(!isWasmInitialized) {
15568 throw new Error("initializeWasm() must be awaited first!");
15570 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
15571 return nativeResponseValue;
15573 // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
15575 export function CVec_BlindedHopZ_free(_res: number): void {
15576 if(!isWasmInitialized) {
15577 throw new Error("initializeWasm() must be awaited first!");
15579 const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
15580 // debug statements here
15582 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
15584 export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
15585 if(!isWasmInitialized) {
15586 throw new Error("initializeWasm() must be awaited first!");
15588 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
15589 return nativeResponseValue;
15591 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
15593 export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
15594 if(!isWasmInitialized) {
15595 throw new Error("initializeWasm() must be awaited first!");
15597 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
15598 return nativeResponseValue;
15600 // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
15602 export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
15603 if(!isWasmInitialized) {
15604 throw new Error("initializeWasm() must be awaited first!");
15606 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
15607 return nativeResponseValue;
15609 // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
15611 export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
15612 if(!isWasmInitialized) {
15613 throw new Error("initializeWasm() must be awaited first!");
15615 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
15616 // debug statements here
15618 // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
15620 export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15621 if(!isWasmInitialized) {
15622 throw new Error("initializeWasm() must be awaited first!");
15624 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
15625 return nativeResponseValue;
15627 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
15629 export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
15630 if(!isWasmInitialized) {
15631 throw new Error("initializeWasm() must be awaited first!");
15633 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
15634 return nativeResponseValue;
15636 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
15638 export function CVec_RouteHopZ_free(_res: number): void {
15639 if(!isWasmInitialized) {
15640 throw new Error("initializeWasm() must be awaited first!");
15642 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
15643 // debug statements here
15645 // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
15647 export function CVec_PathZ_free(_res: number): void {
15648 if(!isWasmInitialized) {
15649 throw new Error("initializeWasm() must be awaited first!");
15651 const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
15652 // debug statements here
15654 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
15656 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
15657 if(!isWasmInitialized) {
15658 throw new Error("initializeWasm() must be awaited first!");
15660 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
15661 return nativeResponseValue;
15663 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
15665 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
15666 if(!isWasmInitialized) {
15667 throw new Error("initializeWasm() must be awaited first!");
15669 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
15670 return nativeResponseValue;
15672 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
15674 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
15675 if(!isWasmInitialized) {
15676 throw new Error("initializeWasm() must be awaited first!");
15678 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
15679 return nativeResponseValue;
15681 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
15683 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
15684 if(!isWasmInitialized) {
15685 throw new Error("initializeWasm() must be awaited first!");
15687 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
15688 // debug statements here
15690 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
15692 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15693 if(!isWasmInitialized) {
15694 throw new Error("initializeWasm() must be awaited first!");
15696 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
15697 return nativeResponseValue;
15699 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
15701 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
15702 if(!isWasmInitialized) {
15703 throw new Error("initializeWasm() must be awaited first!");
15705 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
15706 return nativeResponseValue;
15708 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
15710 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
15711 if(!isWasmInitialized) {
15712 throw new Error("initializeWasm() must be awaited first!");
15714 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
15715 return nativeResponseValue;
15717 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
15719 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
15720 if(!isWasmInitialized) {
15721 throw new Error("initializeWasm() must be awaited first!");
15723 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
15724 return nativeResponseValue;
15726 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
15728 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
15729 if(!isWasmInitialized) {
15730 throw new Error("initializeWasm() must be awaited first!");
15732 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
15733 return nativeResponseValue;
15735 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
15737 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
15738 if(!isWasmInitialized) {
15739 throw new Error("initializeWasm() must be awaited first!");
15741 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
15742 // debug statements here
15744 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
15746 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15747 if(!isWasmInitialized) {
15748 throw new Error("initializeWasm() must be awaited first!");
15750 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
15751 return nativeResponseValue;
15753 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
15755 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
15756 if(!isWasmInitialized) {
15757 throw new Error("initializeWasm() must be awaited first!");
15759 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
15760 return nativeResponseValue;
15762 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
15764 export function CVec_u64Z_free(_res: number): void {
15765 if(!isWasmInitialized) {
15766 throw new Error("initializeWasm() must be awaited first!");
15768 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
15769 // debug statements here
15771 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
15773 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
15774 if(!isWasmInitialized) {
15775 throw new Error("initializeWasm() must be awaited first!");
15777 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
15778 return nativeResponseValue;
15780 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
15782 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
15783 if(!isWasmInitialized) {
15784 throw new Error("initializeWasm() must be awaited first!");
15786 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
15787 return nativeResponseValue;
15789 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
15791 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
15792 if(!isWasmInitialized) {
15793 throw new Error("initializeWasm() must be awaited first!");
15795 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
15796 return nativeResponseValue;
15798 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
15800 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
15801 if(!isWasmInitialized) {
15802 throw new Error("initializeWasm() must be awaited first!");
15804 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
15805 // debug statements here
15807 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
15809 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15810 if(!isWasmInitialized) {
15811 throw new Error("initializeWasm() must be awaited first!");
15813 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
15814 return nativeResponseValue;
15816 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
15818 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
15819 if(!isWasmInitialized) {
15820 throw new Error("initializeWasm() must be awaited first!");
15822 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
15823 return nativeResponseValue;
15825 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
15827 export function CVec_RouteHintZ_free(_res: number): void {
15828 if(!isWasmInitialized) {
15829 throw new Error("initializeWasm() must be awaited first!");
15831 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
15832 // debug statements here
15834 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
15836 export function CVec_RouteHintHopZ_free(_res: number): void {
15837 if(!isWasmInitialized) {
15838 throw new Error("initializeWasm() must be awaited first!");
15840 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
15841 // debug statements here
15843 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
15845 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
15846 if(!isWasmInitialized) {
15847 throw new Error("initializeWasm() must be awaited first!");
15849 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
15850 return nativeResponseValue;
15852 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
15854 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
15855 if(!isWasmInitialized) {
15856 throw new Error("initializeWasm() must be awaited first!");
15858 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
15859 return nativeResponseValue;
15861 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
15863 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
15864 if(!isWasmInitialized) {
15865 throw new Error("initializeWasm() must be awaited first!");
15867 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
15868 return nativeResponseValue;
15870 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
15872 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
15873 if(!isWasmInitialized) {
15874 throw new Error("initializeWasm() must be awaited first!");
15876 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
15877 // debug statements here
15879 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
15881 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15882 if(!isWasmInitialized) {
15883 throw new Error("initializeWasm() must be awaited first!");
15885 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
15886 return nativeResponseValue;
15888 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
15890 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
15891 if(!isWasmInitialized) {
15892 throw new Error("initializeWasm() must be awaited first!");
15894 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
15895 return nativeResponseValue;
15897 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
15899 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
15900 if(!isWasmInitialized) {
15901 throw new Error("initializeWasm() must be awaited first!");
15903 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
15904 return nativeResponseValue;
15906 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
15908 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
15909 if(!isWasmInitialized) {
15910 throw new Error("initializeWasm() must be awaited first!");
15912 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
15913 return nativeResponseValue;
15915 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
15917 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
15918 if(!isWasmInitialized) {
15919 throw new Error("initializeWasm() must be awaited first!");
15921 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
15922 return nativeResponseValue;
15924 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
15926 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
15927 if(!isWasmInitialized) {
15928 throw new Error("initializeWasm() must be awaited first!");
15930 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
15931 // debug statements here
15933 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
15935 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15936 if(!isWasmInitialized) {
15937 throw new Error("initializeWasm() must be awaited first!");
15939 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
15940 return nativeResponseValue;
15942 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
15944 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
15945 if(!isWasmInitialized) {
15946 throw new Error("initializeWasm() must be awaited first!");
15948 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
15949 return nativeResponseValue;
15951 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
15953 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
15954 if(!isWasmInitialized) {
15955 throw new Error("initializeWasm() must be awaited first!");
15957 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
15958 return nativeResponseValue;
15960 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
15962 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
15963 if(!isWasmInitialized) {
15964 throw new Error("initializeWasm() must be awaited first!");
15966 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
15967 return nativeResponseValue;
15969 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
15971 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
15972 if(!isWasmInitialized) {
15973 throw new Error("initializeWasm() must be awaited first!");
15975 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
15976 return nativeResponseValue;
15978 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
15980 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
15981 if(!isWasmInitialized) {
15982 throw new Error("initializeWasm() must be awaited first!");
15984 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
15985 // debug statements here
15987 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
15989 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15990 if(!isWasmInitialized) {
15991 throw new Error("initializeWasm() must be awaited first!");
15993 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
15994 return nativeResponseValue;
15996 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
15998 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
15999 if(!isWasmInitialized) {
16000 throw new Error("initializeWasm() must be awaited first!");
16002 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
16003 return nativeResponseValue;
16005 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
16007 export function CVec_NodeIdZ_free(_res: number): void {
16008 if(!isWasmInitialized) {
16009 throw new Error("initializeWasm() must be awaited first!");
16011 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
16012 // debug statements here
16014 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
16016 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
16017 if(!isWasmInitialized) {
16018 throw new Error("initializeWasm() must be awaited first!");
16020 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
16021 return nativeResponseValue;
16023 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
16025 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
16026 if(!isWasmInitialized) {
16027 throw new Error("initializeWasm() must be awaited first!");
16029 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
16030 return nativeResponseValue;
16032 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
16034 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
16035 if(!isWasmInitialized) {
16036 throw new Error("initializeWasm() must be awaited first!");
16038 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
16039 return nativeResponseValue;
16041 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
16043 export function C2Tuple_u64u64Z_free(_res: bigint): void {
16044 if(!isWasmInitialized) {
16045 throw new Error("initializeWasm() must be awaited first!");
16047 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
16048 // debug statements here
16050 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
16052 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
16053 if(!isWasmInitialized) {
16054 throw new Error("initializeWasm() must be awaited first!");
16056 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
16057 return nativeResponseValue;
16059 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
16061 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
16062 if(!isWasmInitialized) {
16063 throw new Error("initializeWasm() must be awaited first!");
16065 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
16066 return nativeResponseValue;
16068 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
16070 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
16071 if(!isWasmInitialized) {
16072 throw new Error("initializeWasm() must be awaited first!");
16074 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
16075 // debug statements here
16077 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
16079 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
16080 if(!isWasmInitialized) {
16081 throw new Error("initializeWasm() must be awaited first!");
16083 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
16084 return nativeResponseValue;
16086 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
16088 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
16089 if(!isWasmInitialized) {
16090 throw new Error("initializeWasm() must be awaited first!");
16092 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
16093 return nativeResponseValue;
16095 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
16097 export function C2Tuple_Z_new(a: number, b: number): bigint {
16098 if(!isWasmInitialized) {
16099 throw new Error("initializeWasm() must be awaited first!");
16101 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
16102 return nativeResponseValue;
16104 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
16106 export function C2Tuple_Z_free(_res: bigint): void {
16107 if(!isWasmInitialized) {
16108 throw new Error("initializeWasm() must be awaited first!");
16110 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
16111 // debug statements here
16113 // struct LDKC2Tuple__u1632_u1632Z C2Tuple__u1632_u1632Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
16115 export function C2Tuple__u1632_u1632Z_new(a: number, b: number): bigint {
16116 if(!isWasmInitialized) {
16117 throw new Error("initializeWasm() must be awaited first!");
16119 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_new(a, b);
16120 return nativeResponseValue;
16122 // void C2Tuple__u1632_u1632Z_free(struct LDKC2Tuple__u1632_u1632Z _res);
16124 export function C2Tuple__u1632_u1632Z_free(_res: bigint): void {
16125 if(!isWasmInitialized) {
16126 throw new Error("initializeWasm() must be awaited first!");
16128 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_free(_res);
16129 // debug statements here
16131 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(struct LDKC2Tuple__u1632_u1632Z o);
16133 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o: bigint): bigint {
16134 if(!isWasmInitialized) {
16135 throw new Error("initializeWasm() must be awaited first!");
16137 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o);
16138 return nativeResponseValue;
16140 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(void);
16142 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(): bigint {
16143 if(!isWasmInitialized) {
16144 throw new Error("initializeWasm() must be awaited first!");
16146 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
16147 return nativeResponseValue;
16149 // void COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res);
16151 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res: bigint): void {
16152 if(!isWasmInitialized) {
16153 throw new Error("initializeWasm() must be awaited first!");
16155 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res);
16156 // debug statements here
16158 // struct LDKCOption_f64Z COption_f64Z_some(double o);
16160 export function COption_f64Z_some(o: number): bigint {
16161 if(!isWasmInitialized) {
16162 throw new Error("initializeWasm() must be awaited first!");
16164 const nativeResponseValue = wasm.TS_COption_f64Z_some(o);
16165 return nativeResponseValue;
16167 // struct LDKCOption_f64Z COption_f64Z_none(void);
16169 export function COption_f64Z_none(): bigint {
16170 if(!isWasmInitialized) {
16171 throw new Error("initializeWasm() must be awaited first!");
16173 const nativeResponseValue = wasm.TS_COption_f64Z_none();
16174 return nativeResponseValue;
16176 // void COption_f64Z_free(struct LDKCOption_f64Z _res);
16178 export function COption_f64Z_free(_res: bigint): void {
16179 if(!isWasmInitialized) {
16180 throw new Error("initializeWasm() must be awaited first!");
16182 const nativeResponseValue = wasm.TS_COption_f64Z_free(_res);
16183 // debug statements here
16185 // uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg);
16187 export function COption_f64Z_clone_ptr(arg: bigint): bigint {
16188 if(!isWasmInitialized) {
16189 throw new Error("initializeWasm() must be awaited first!");
16191 const nativeResponseValue = wasm.TS_COption_f64Z_clone_ptr(arg);
16192 return nativeResponseValue;
16194 // struct LDKCOption_f64Z COption_f64Z_clone(const struct LDKCOption_f64Z *NONNULL_PTR orig);
16196 export function COption_f64Z_clone(orig: bigint): bigint {
16197 if(!isWasmInitialized) {
16198 throw new Error("initializeWasm() must be awaited first!");
16200 const nativeResponseValue = wasm.TS_COption_f64Z_clone(orig);
16201 return nativeResponseValue;
16203 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
16205 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
16206 if(!isWasmInitialized) {
16207 throw new Error("initializeWasm() must be awaited first!");
16209 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
16210 return nativeResponseValue;
16212 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
16214 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
16215 if(!isWasmInitialized) {
16216 throw new Error("initializeWasm() must be awaited first!");
16218 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
16219 return nativeResponseValue;
16221 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
16223 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
16224 if(!isWasmInitialized) {
16225 throw new Error("initializeWasm() must be awaited first!");
16227 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
16228 return nativeResponseValue;
16230 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
16232 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
16233 if(!isWasmInitialized) {
16234 throw new Error("initializeWasm() must be awaited first!");
16236 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
16237 // debug statements here
16239 // struct LDKCResult_BestBlockDecodeErrorZ CResult_BestBlockDecodeErrorZ_ok(struct LDKBestBlock o);
16241 export function CResult_BestBlockDecodeErrorZ_ok(o: bigint): bigint {
16242 if(!isWasmInitialized) {
16243 throw new Error("initializeWasm() must be awaited first!");
16245 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_ok(o);
16246 return nativeResponseValue;
16248 // struct LDKCResult_BestBlockDecodeErrorZ CResult_BestBlockDecodeErrorZ_err(struct LDKDecodeError e);
16250 export function CResult_BestBlockDecodeErrorZ_err(e: bigint): bigint {
16251 if(!isWasmInitialized) {
16252 throw new Error("initializeWasm() must be awaited first!");
16254 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_err(e);
16255 return nativeResponseValue;
16257 // bool CResult_BestBlockDecodeErrorZ_is_ok(const struct LDKCResult_BestBlockDecodeErrorZ *NONNULL_PTR o);
16259 export function CResult_BestBlockDecodeErrorZ_is_ok(o: bigint): boolean {
16260 if(!isWasmInitialized) {
16261 throw new Error("initializeWasm() must be awaited first!");
16263 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_is_ok(o);
16264 return nativeResponseValue;
16266 // void CResult_BestBlockDecodeErrorZ_free(struct LDKCResult_BestBlockDecodeErrorZ _res);
16268 export function CResult_BestBlockDecodeErrorZ_free(_res: bigint): void {
16269 if(!isWasmInitialized) {
16270 throw new Error("initializeWasm() must be awaited first!");
16272 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_free(_res);
16273 // debug statements here
16275 // uint64_t CResult_BestBlockDecodeErrorZ_clone_ptr(LDKCResult_BestBlockDecodeErrorZ *NONNULL_PTR arg);
16277 export function CResult_BestBlockDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16278 if(!isWasmInitialized) {
16279 throw new Error("initializeWasm() must be awaited first!");
16281 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_clone_ptr(arg);
16282 return nativeResponseValue;
16284 // struct LDKCResult_BestBlockDecodeErrorZ CResult_BestBlockDecodeErrorZ_clone(const struct LDKCResult_BestBlockDecodeErrorZ *NONNULL_PTR orig);
16286 export function CResult_BestBlockDecodeErrorZ_clone(orig: bigint): bigint {
16287 if(!isWasmInitialized) {
16288 throw new Error("initializeWasm() must be awaited first!");
16290 const nativeResponseValue = wasm.TS_CResult_BestBlockDecodeErrorZ_clone(orig);
16291 return nativeResponseValue;
16293 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
16295 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
16296 if(!isWasmInitialized) {
16297 throw new Error("initializeWasm() must be awaited first!");
16299 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
16300 return nativeResponseValue;
16302 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
16304 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
16305 if(!isWasmInitialized) {
16306 throw new Error("initializeWasm() must be awaited first!");
16308 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
16309 return nativeResponseValue;
16311 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
16313 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
16314 if(!isWasmInitialized) {
16315 throw new Error("initializeWasm() must be awaited first!");
16317 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
16318 return nativeResponseValue;
16320 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
16322 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
16323 if(!isWasmInitialized) {
16324 throw new Error("initializeWasm() must be awaited first!");
16326 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
16327 // debug statements here
16329 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
16331 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
16332 if(!isWasmInitialized) {
16333 throw new Error("initializeWasm() must be awaited first!");
16335 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
16336 // debug statements here
16338 // uint64_t C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR arg);
16340 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
16341 if(!isWasmInitialized) {
16342 throw new Error("initializeWasm() must be awaited first!");
16344 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(arg);
16345 return nativeResponseValue;
16347 // struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(const struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR orig);
16349 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
16350 if(!isWasmInitialized) {
16351 throw new Error("initializeWasm() must be awaited first!");
16353 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(orig);
16354 return nativeResponseValue;
16356 // struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(struct LDKThirtyTwoBytes a, uint32_t b, struct LDKCOption_ThirtyTwoBytesZ c);
16358 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(a: number, b: number, c: bigint): bigint {
16359 if(!isWasmInitialized) {
16360 throw new Error("initializeWasm() must be awaited first!");
16362 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(a, b, c);
16363 return nativeResponseValue;
16365 // void C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ _res);
16367 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(_res: bigint): void {
16368 if(!isWasmInitialized) {
16369 throw new Error("initializeWasm() must be awaited first!");
16371 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(_res);
16372 // debug statements here
16374 // void CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(struct LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ _res);
16376 export function CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(_res: number): void {
16377 if(!isWasmInitialized) {
16378 throw new Error("initializeWasm() must be awaited first!");
16380 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(_res);
16381 // debug statements here
16383 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_ok(enum LDKChannelMonitorUpdateStatus o);
16385 export function CResult_ChannelMonitorUpdateStatusNoneZ_ok(o: ChannelMonitorUpdateStatus): bigint {
16386 if(!isWasmInitialized) {
16387 throw new Error("initializeWasm() must be awaited first!");
16389 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(o);
16390 return nativeResponseValue;
16392 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_err(void);
16394 export function CResult_ChannelMonitorUpdateStatusNoneZ_err(): bigint {
16395 if(!isWasmInitialized) {
16396 throw new Error("initializeWasm() must be awaited first!");
16398 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_err();
16399 return nativeResponseValue;
16401 // bool CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR o);
16403 export function CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o: bigint): boolean {
16404 if(!isWasmInitialized) {
16405 throw new Error("initializeWasm() must be awaited first!");
16407 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o);
16408 return nativeResponseValue;
16410 // void CResult_ChannelMonitorUpdateStatusNoneZ_free(struct LDKCResult_ChannelMonitorUpdateStatusNoneZ _res);
16412 export function CResult_ChannelMonitorUpdateStatusNoneZ_free(_res: bigint): void {
16413 if(!isWasmInitialized) {
16414 throw new Error("initializeWasm() must be awaited first!");
16416 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(_res);
16417 // debug statements here
16419 // uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg);
16421 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg: bigint): bigint {
16422 if(!isWasmInitialized) {
16423 throw new Error("initializeWasm() must be awaited first!");
16425 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg);
16426 return nativeResponseValue;
16428 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_clone(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR orig);
16430 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig: bigint): bigint {
16431 if(!isWasmInitialized) {
16432 throw new Error("initializeWasm() must be awaited first!");
16434 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig);
16435 return nativeResponseValue;
16437 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
16439 export function CVec_MonitorEventZ_free(_res: number): void {
16440 if(!isWasmInitialized) {
16441 throw new Error("initializeWasm() must be awaited first!");
16443 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
16444 // debug statements here
16446 // uint64_t C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
16448 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
16449 if(!isWasmInitialized) {
16450 throw new Error("initializeWasm() must be awaited first!");
16452 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
16453 return nativeResponseValue;
16455 // struct LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
16457 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
16458 if(!isWasmInitialized) {
16459 throw new Error("initializeWasm() must be awaited first!");
16461 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_clone(orig);
16462 return nativeResponseValue;
16464 // struct LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKChannelId b, struct LDKCVec_MonitorEventZ c, struct LDKPublicKey d);
16466 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: bigint, c: number, d: number): bigint {
16467 if(!isWasmInitialized) {
16468 throw new Error("initializeWasm() must be awaited first!");
16470 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_new(a, b, c, d);
16471 return nativeResponseValue;
16473 // void C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(struct LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ _res);
16475 export function C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
16476 if(!isWasmInitialized) {
16477 throw new Error("initializeWasm() must be awaited first!");
16479 const nativeResponseValue = wasm.TS_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(_res);
16480 // debug statements here
16482 // void CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ _res);
16484 export function CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
16485 if(!isWasmInitialized) {
16486 throw new Error("initializeWasm() must be awaited first!");
16488 const nativeResponseValue = wasm.TS_CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(_res);
16489 // debug statements here
16491 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
16493 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16494 if(!isWasmInitialized) {
16495 throw new Error("initializeWasm() must be awaited first!");
16497 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
16498 return nativeResponseValue;
16500 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16502 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
16503 if(!isWasmInitialized) {
16504 throw new Error("initializeWasm() must be awaited first!");
16506 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
16507 return nativeResponseValue;
16509 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
16511 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16512 if(!isWasmInitialized) {
16513 throw new Error("initializeWasm() must be awaited first!");
16515 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
16516 return nativeResponseValue;
16518 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
16520 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
16521 if(!isWasmInitialized) {
16522 throw new Error("initializeWasm() must be awaited first!");
16524 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
16525 // debug statements here
16527 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
16529 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16530 if(!isWasmInitialized) {
16531 throw new Error("initializeWasm() must be awaited first!");
16533 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
16534 return nativeResponseValue;
16536 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
16538 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16539 if(!isWasmInitialized) {
16540 throw new Error("initializeWasm() must be awaited first!");
16542 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
16543 return nativeResponseValue;
16545 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
16547 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16548 if(!isWasmInitialized) {
16549 throw new Error("initializeWasm() must be awaited first!");
16551 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
16552 return nativeResponseValue;
16554 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16556 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
16557 if(!isWasmInitialized) {
16558 throw new Error("initializeWasm() must be awaited first!");
16560 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
16561 return nativeResponseValue;
16563 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
16565 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16566 if(!isWasmInitialized) {
16567 throw new Error("initializeWasm() must be awaited first!");
16569 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
16570 return nativeResponseValue;
16572 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
16574 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
16575 if(!isWasmInitialized) {
16576 throw new Error("initializeWasm() must be awaited first!");
16578 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
16579 // debug statements here
16581 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
16583 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16584 if(!isWasmInitialized) {
16585 throw new Error("initializeWasm() must be awaited first!");
16587 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
16588 return nativeResponseValue;
16590 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
16592 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16593 if(!isWasmInitialized) {
16594 throw new Error("initializeWasm() must be awaited first!");
16596 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
16597 return nativeResponseValue;
16599 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
16601 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16602 if(!isWasmInitialized) {
16603 throw new Error("initializeWasm() must be awaited first!");
16605 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
16606 return nativeResponseValue;
16608 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16610 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
16611 if(!isWasmInitialized) {
16612 throw new Error("initializeWasm() must be awaited first!");
16614 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
16615 return nativeResponseValue;
16617 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
16619 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16620 if(!isWasmInitialized) {
16621 throw new Error("initializeWasm() must be awaited first!");
16623 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
16624 return nativeResponseValue;
16626 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
16628 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
16629 if(!isWasmInitialized) {
16630 throw new Error("initializeWasm() must be awaited first!");
16632 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
16633 // debug statements here
16635 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
16637 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16638 if(!isWasmInitialized) {
16639 throw new Error("initializeWasm() must be awaited first!");
16641 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
16642 return nativeResponseValue;
16644 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
16646 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16647 if(!isWasmInitialized) {
16648 throw new Error("initializeWasm() must be awaited first!");
16650 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
16651 return nativeResponseValue;
16653 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
16655 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16656 if(!isWasmInitialized) {
16657 throw new Error("initializeWasm() must be awaited first!");
16659 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
16660 return nativeResponseValue;
16662 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16664 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
16665 if(!isWasmInitialized) {
16666 throw new Error("initializeWasm() must be awaited first!");
16668 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
16669 return nativeResponseValue;
16671 // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
16673 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16674 if(!isWasmInitialized) {
16675 throw new Error("initializeWasm() must be awaited first!");
16677 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
16678 return nativeResponseValue;
16680 // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
16682 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
16683 if(!isWasmInitialized) {
16684 throw new Error("initializeWasm() must be awaited first!");
16686 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
16687 // debug statements here
16689 // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
16691 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16692 if(!isWasmInitialized) {
16693 throw new Error("initializeWasm() must be awaited first!");
16695 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
16696 return nativeResponseValue;
16698 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
16700 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16701 if(!isWasmInitialized) {
16702 throw new Error("initializeWasm() must be awaited first!");
16704 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
16705 return nativeResponseValue;
16707 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
16709 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16710 if(!isWasmInitialized) {
16711 throw new Error("initializeWasm() must be awaited first!");
16713 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
16714 return nativeResponseValue;
16716 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16718 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
16719 if(!isWasmInitialized) {
16720 throw new Error("initializeWasm() must be awaited first!");
16722 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
16723 return nativeResponseValue;
16725 // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
16727 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16728 if(!isWasmInitialized) {
16729 throw new Error("initializeWasm() must be awaited first!");
16731 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
16732 return nativeResponseValue;
16734 // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
16736 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
16737 if(!isWasmInitialized) {
16738 throw new Error("initializeWasm() must be awaited first!");
16740 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
16741 // debug statements here
16743 // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
16745 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16746 if(!isWasmInitialized) {
16747 throw new Error("initializeWasm() must be awaited first!");
16749 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
16750 return nativeResponseValue;
16752 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
16754 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16755 if(!isWasmInitialized) {
16756 throw new Error("initializeWasm() must be awaited first!");
16758 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
16759 return nativeResponseValue;
16761 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
16763 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16764 if(!isWasmInitialized) {
16765 throw new Error("initializeWasm() must be awaited first!");
16767 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
16768 return nativeResponseValue;
16770 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16772 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
16773 if(!isWasmInitialized) {
16774 throw new Error("initializeWasm() must be awaited first!");
16776 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
16777 return nativeResponseValue;
16779 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
16781 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16782 if(!isWasmInitialized) {
16783 throw new Error("initializeWasm() must be awaited first!");
16785 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
16786 return nativeResponseValue;
16788 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
16790 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
16791 if(!isWasmInitialized) {
16792 throw new Error("initializeWasm() must be awaited first!");
16794 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
16795 // debug statements here
16797 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
16799 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16800 if(!isWasmInitialized) {
16801 throw new Error("initializeWasm() must be awaited first!");
16803 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
16804 return nativeResponseValue;
16806 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
16808 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16809 if(!isWasmInitialized) {
16810 throw new Error("initializeWasm() must be awaited first!");
16812 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
16813 return nativeResponseValue;
16815 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
16817 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
16818 if(!isWasmInitialized) {
16819 throw new Error("initializeWasm() must be awaited first!");
16821 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
16822 return nativeResponseValue;
16824 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
16826 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
16827 if(!isWasmInitialized) {
16828 throw new Error("initializeWasm() must be awaited first!");
16830 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
16831 return nativeResponseValue;
16833 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
16835 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
16836 if(!isWasmInitialized) {
16837 throw new Error("initializeWasm() must be awaited first!");
16839 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
16840 return nativeResponseValue;
16842 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
16844 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
16845 if(!isWasmInitialized) {
16846 throw new Error("initializeWasm() must be awaited first!");
16848 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
16849 // debug statements here
16851 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
16853 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16854 if(!isWasmInitialized) {
16855 throw new Error("initializeWasm() must be awaited first!");
16857 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
16858 return nativeResponseValue;
16860 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
16862 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
16863 if(!isWasmInitialized) {
16864 throw new Error("initializeWasm() must be awaited first!");
16866 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
16867 return nativeResponseValue;
16869 // struct LDKCResult_OfferIdDecodeErrorZ CResult_OfferIdDecodeErrorZ_ok(struct LDKOfferId o);
16871 export function CResult_OfferIdDecodeErrorZ_ok(o: bigint): bigint {
16872 if(!isWasmInitialized) {
16873 throw new Error("initializeWasm() must be awaited first!");
16875 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_ok(o);
16876 return nativeResponseValue;
16878 // struct LDKCResult_OfferIdDecodeErrorZ CResult_OfferIdDecodeErrorZ_err(struct LDKDecodeError e);
16880 export function CResult_OfferIdDecodeErrorZ_err(e: bigint): bigint {
16881 if(!isWasmInitialized) {
16882 throw new Error("initializeWasm() must be awaited first!");
16884 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_err(e);
16885 return nativeResponseValue;
16887 // bool CResult_OfferIdDecodeErrorZ_is_ok(const struct LDKCResult_OfferIdDecodeErrorZ *NONNULL_PTR o);
16889 export function CResult_OfferIdDecodeErrorZ_is_ok(o: bigint): boolean {
16890 if(!isWasmInitialized) {
16891 throw new Error("initializeWasm() must be awaited first!");
16893 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_is_ok(o);
16894 return nativeResponseValue;
16896 // void CResult_OfferIdDecodeErrorZ_free(struct LDKCResult_OfferIdDecodeErrorZ _res);
16898 export function CResult_OfferIdDecodeErrorZ_free(_res: bigint): void {
16899 if(!isWasmInitialized) {
16900 throw new Error("initializeWasm() must be awaited first!");
16902 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_free(_res);
16903 // debug statements here
16905 // uint64_t CResult_OfferIdDecodeErrorZ_clone_ptr(LDKCResult_OfferIdDecodeErrorZ *NONNULL_PTR arg);
16907 export function CResult_OfferIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16908 if(!isWasmInitialized) {
16909 throw new Error("initializeWasm() must be awaited first!");
16911 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_clone_ptr(arg);
16912 return nativeResponseValue;
16914 // struct LDKCResult_OfferIdDecodeErrorZ CResult_OfferIdDecodeErrorZ_clone(const struct LDKCResult_OfferIdDecodeErrorZ *NONNULL_PTR orig);
16916 export function CResult_OfferIdDecodeErrorZ_clone(orig: bigint): bigint {
16917 if(!isWasmInitialized) {
16918 throw new Error("initializeWasm() must be awaited first!");
16920 const nativeResponseValue = wasm.TS_CResult_OfferIdDecodeErrorZ_clone(orig);
16921 return nativeResponseValue;
16923 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_ok(void);
16925 export function CResult_NoneBolt12SemanticErrorZ_ok(): bigint {
16926 if(!isWasmInitialized) {
16927 throw new Error("initializeWasm() must be awaited first!");
16929 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_ok();
16930 return nativeResponseValue;
16932 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
16934 export function CResult_NoneBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
16935 if(!isWasmInitialized) {
16936 throw new Error("initializeWasm() must be awaited first!");
16938 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_err(e);
16939 return nativeResponseValue;
16941 // bool CResult_NoneBolt12SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR o);
16943 export function CResult_NoneBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
16944 if(!isWasmInitialized) {
16945 throw new Error("initializeWasm() must be awaited first!");
16947 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_is_ok(o);
16948 return nativeResponseValue;
16950 // void CResult_NoneBolt12SemanticErrorZ_free(struct LDKCResult_NoneBolt12SemanticErrorZ _res);
16952 export function CResult_NoneBolt12SemanticErrorZ_free(_res: bigint): void {
16953 if(!isWasmInitialized) {
16954 throw new Error("initializeWasm() must be awaited first!");
16956 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_free(_res);
16957 // debug statements here
16959 // uint64_t CResult_NoneBolt12SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR arg);
16961 export function CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
16962 if(!isWasmInitialized) {
16963 throw new Error("initializeWasm() must be awaited first!");
16965 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg);
16966 return nativeResponseValue;
16968 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_clone(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR orig);
16970 export function CResult_NoneBolt12SemanticErrorZ_clone(orig: bigint): bigint {
16971 if(!isWasmInitialized) {
16972 throw new Error("initializeWasm() must be awaited first!");
16974 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone(orig);
16975 return nativeResponseValue;
16977 // struct LDKCResult_OfferBolt12SemanticErrorZ CResult_OfferBolt12SemanticErrorZ_ok(struct LDKOffer o);
16979 export function CResult_OfferBolt12SemanticErrorZ_ok(o: bigint): bigint {
16980 if(!isWasmInitialized) {
16981 throw new Error("initializeWasm() must be awaited first!");
16983 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_ok(o);
16984 return nativeResponseValue;
16986 // struct LDKCResult_OfferBolt12SemanticErrorZ CResult_OfferBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
16988 export function CResult_OfferBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
16989 if(!isWasmInitialized) {
16990 throw new Error("initializeWasm() must be awaited first!");
16992 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_err(e);
16993 return nativeResponseValue;
16995 // bool CResult_OfferBolt12SemanticErrorZ_is_ok(const struct LDKCResult_OfferBolt12SemanticErrorZ *NONNULL_PTR o);
16997 export function CResult_OfferBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
16998 if(!isWasmInitialized) {
16999 throw new Error("initializeWasm() must be awaited first!");
17001 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_is_ok(o);
17002 return nativeResponseValue;
17004 // void CResult_OfferBolt12SemanticErrorZ_free(struct LDKCResult_OfferBolt12SemanticErrorZ _res);
17006 export function CResult_OfferBolt12SemanticErrorZ_free(_res: bigint): void {
17007 if(!isWasmInitialized) {
17008 throw new Error("initializeWasm() must be awaited first!");
17010 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_free(_res);
17011 // debug statements here
17013 // uint64_t CResult_OfferBolt12SemanticErrorZ_clone_ptr(LDKCResult_OfferBolt12SemanticErrorZ *NONNULL_PTR arg);
17015 export function CResult_OfferBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
17016 if(!isWasmInitialized) {
17017 throw new Error("initializeWasm() must be awaited first!");
17019 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_clone_ptr(arg);
17020 return nativeResponseValue;
17022 // struct LDKCResult_OfferBolt12SemanticErrorZ CResult_OfferBolt12SemanticErrorZ_clone(const struct LDKCResult_OfferBolt12SemanticErrorZ *NONNULL_PTR orig);
17024 export function CResult_OfferBolt12SemanticErrorZ_clone(orig: bigint): bigint {
17025 if(!isWasmInitialized) {
17026 throw new Error("initializeWasm() must be awaited first!");
17028 const nativeResponseValue = wasm.TS_CResult_OfferBolt12SemanticErrorZ_clone(orig);
17029 return nativeResponseValue;
17031 // struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_ok(struct LDKInvoiceRequestWithDerivedPayerIdBuilder o);
17033 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
17034 if(!isWasmInitialized) {
17035 throw new Error("initializeWasm() must be awaited first!");
17037 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_ok(o);
17038 return nativeResponseValue;
17040 // struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
17042 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
17043 if(!isWasmInitialized) {
17044 throw new Error("initializeWasm() must be awaited first!");
17046 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_err(e);
17047 return nativeResponseValue;
17049 // bool CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
17051 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
17052 if(!isWasmInitialized) {
17053 throw new Error("initializeWasm() must be awaited first!");
17055 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_is_ok(o);
17056 return nativeResponseValue;
17058 // void CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ _res);
17060 export function CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
17061 if(!isWasmInitialized) {
17062 throw new Error("initializeWasm() must be awaited first!");
17064 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(_res);
17065 // debug statements here
17067 // struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_ok(struct LDKInvoiceRequestWithExplicitPayerIdBuilder o);
17069 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
17070 if(!isWasmInitialized) {
17071 throw new Error("initializeWasm() must be awaited first!");
17073 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_ok(o);
17074 return nativeResponseValue;
17076 // struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
17078 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
17079 if(!isWasmInitialized) {
17080 throw new Error("initializeWasm() must be awaited first!");
17082 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_err(e);
17083 return nativeResponseValue;
17085 // bool CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
17087 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
17088 if(!isWasmInitialized) {
17089 throw new Error("initializeWasm() must be awaited first!");
17091 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_is_ok(o);
17092 return nativeResponseValue;
17094 // void CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ _res);
17096 export function CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
17097 if(!isWasmInitialized) {
17098 throw new Error("initializeWasm() must be awaited first!");
17100 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(_res);
17101 // debug statements here
17103 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
17105 export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
17106 if(!isWasmInitialized) {
17107 throw new Error("initializeWasm() must be awaited first!");
17109 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
17110 return nativeResponseValue;
17112 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
17114 export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
17115 if(!isWasmInitialized) {
17116 throw new Error("initializeWasm() must be awaited first!");
17118 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
17119 return nativeResponseValue;
17121 // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
17123 export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
17124 if(!isWasmInitialized) {
17125 throw new Error("initializeWasm() must be awaited first!");
17127 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
17128 return nativeResponseValue;
17130 // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
17132 export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
17133 if(!isWasmInitialized) {
17134 throw new Error("initializeWasm() must be awaited first!");
17136 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
17137 // debug statements here
17139 // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
17141 export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
17142 if(!isWasmInitialized) {
17143 throw new Error("initializeWasm() must be awaited first!");
17145 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
17146 return nativeResponseValue;
17148 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
17150 export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
17151 if(!isWasmInitialized) {
17152 throw new Error("initializeWasm() must be awaited first!");
17154 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);
17155 return nativeResponseValue;
17157 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
17159 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
17160 if(!isWasmInitialized) {
17161 throw new Error("initializeWasm() must be awaited first!");
17163 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
17164 return nativeResponseValue;
17166 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
17168 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
17169 if(!isWasmInitialized) {
17170 throw new Error("initializeWasm() must be awaited first!");
17172 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
17173 return nativeResponseValue;
17175 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
17177 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
17178 if(!isWasmInitialized) {
17179 throw new Error("initializeWasm() must be awaited first!");
17181 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
17182 return nativeResponseValue;
17184 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
17186 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
17187 if(!isWasmInitialized) {
17188 throw new Error("initializeWasm() must be awaited first!");
17190 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
17191 // debug statements here
17193 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
17195 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17196 if(!isWasmInitialized) {
17197 throw new Error("initializeWasm() must be awaited first!");
17199 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
17200 return nativeResponseValue;
17202 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
17204 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
17205 if(!isWasmInitialized) {
17206 throw new Error("initializeWasm() must be awaited first!");
17208 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
17209 return nativeResponseValue;
17211 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_ok(struct LDKPublicKey o);
17213 export function CResult_PublicKeySecp256k1ErrorZ_ok(o: number): bigint {
17214 if(!isWasmInitialized) {
17215 throw new Error("initializeWasm() must be awaited first!");
17217 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_ok(o);
17218 return nativeResponseValue;
17220 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
17222 export function CResult_PublicKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
17223 if(!isWasmInitialized) {
17224 throw new Error("initializeWasm() must be awaited first!");
17226 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_err(e);
17227 return nativeResponseValue;
17229 // bool CResult_PublicKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR o);
17231 export function CResult_PublicKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
17232 if(!isWasmInitialized) {
17233 throw new Error("initializeWasm() must be awaited first!");
17235 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_is_ok(o);
17236 return nativeResponseValue;
17238 // void CResult_PublicKeySecp256k1ErrorZ_free(struct LDKCResult_PublicKeySecp256k1ErrorZ _res);
17240 export function CResult_PublicKeySecp256k1ErrorZ_free(_res: bigint): void {
17241 if(!isWasmInitialized) {
17242 throw new Error("initializeWasm() must be awaited first!");
17244 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_free(_res);
17245 // debug statements here
17247 // uint64_t CResult_PublicKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR arg);
17249 export function CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
17250 if(!isWasmInitialized) {
17251 throw new Error("initializeWasm() must be awaited first!");
17253 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg);
17254 return nativeResponseValue;
17256 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_clone(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR orig);
17258 export function CResult_PublicKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
17259 if(!isWasmInitialized) {
17260 throw new Error("initializeWasm() must be awaited first!");
17262 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone(orig);
17263 return nativeResponseValue;
17265 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
17267 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
17268 if(!isWasmInitialized) {
17269 throw new Error("initializeWasm() must be awaited first!");
17271 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
17272 return nativeResponseValue;
17274 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
17276 export function COption_NetworkUpdateZ_none(): bigint {
17277 if(!isWasmInitialized) {
17278 throw new Error("initializeWasm() must be awaited first!");
17280 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
17281 return nativeResponseValue;
17283 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
17285 export function COption_NetworkUpdateZ_free(_res: bigint): void {
17286 if(!isWasmInitialized) {
17287 throw new Error("initializeWasm() must be awaited first!");
17289 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
17290 // debug statements here
17292 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
17294 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
17295 if(!isWasmInitialized) {
17296 throw new Error("initializeWasm() must be awaited first!");
17298 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
17299 return nativeResponseValue;
17301 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
17303 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
17304 if(!isWasmInitialized) {
17305 throw new Error("initializeWasm() must be awaited first!");
17307 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
17308 return nativeResponseValue;
17310 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
17312 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
17313 if(!isWasmInitialized) {
17314 throw new Error("initializeWasm() must be awaited first!");
17316 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
17317 return nativeResponseValue;
17319 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
17321 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
17322 if(!isWasmInitialized) {
17323 throw new Error("initializeWasm() must be awaited first!");
17325 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
17326 return nativeResponseValue;
17328 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
17330 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
17331 if(!isWasmInitialized) {
17332 throw new Error("initializeWasm() must be awaited first!");
17334 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
17335 return nativeResponseValue;
17337 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
17339 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
17340 if(!isWasmInitialized) {
17341 throw new Error("initializeWasm() must be awaited first!");
17343 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
17344 // debug statements here
17346 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
17348 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17349 if(!isWasmInitialized) {
17350 throw new Error("initializeWasm() must be awaited first!");
17352 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
17353 return nativeResponseValue;
17355 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
17357 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
17358 if(!isWasmInitialized) {
17359 throw new Error("initializeWasm() must be awaited first!");
17361 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
17362 return nativeResponseValue;
17364 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
17366 export function COption_UtxoLookupZ_some(o: bigint): bigint {
17367 if(!isWasmInitialized) {
17368 throw new Error("initializeWasm() must be awaited first!");
17370 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
17371 return nativeResponseValue;
17373 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
17375 export function COption_UtxoLookupZ_none(): bigint {
17376 if(!isWasmInitialized) {
17377 throw new Error("initializeWasm() must be awaited first!");
17379 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
17380 return nativeResponseValue;
17382 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
17384 export function COption_UtxoLookupZ_free(_res: bigint): void {
17385 if(!isWasmInitialized) {
17386 throw new Error("initializeWasm() must be awaited first!");
17388 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
17389 // debug statements here
17391 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
17393 export function CResult_NoneLightningErrorZ_ok(): bigint {
17394 if(!isWasmInitialized) {
17395 throw new Error("initializeWasm() must be awaited first!");
17397 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
17398 return nativeResponseValue;
17400 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
17402 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
17403 if(!isWasmInitialized) {
17404 throw new Error("initializeWasm() must be awaited first!");
17406 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
17407 return nativeResponseValue;
17409 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
17411 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
17412 if(!isWasmInitialized) {
17413 throw new Error("initializeWasm() must be awaited first!");
17415 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
17416 return nativeResponseValue;
17418 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
17420 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
17421 if(!isWasmInitialized) {
17422 throw new Error("initializeWasm() must be awaited first!");
17424 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
17425 // debug statements here
17427 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
17429 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
17430 if(!isWasmInitialized) {
17431 throw new Error("initializeWasm() must be awaited first!");
17433 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
17434 return nativeResponseValue;
17436 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
17438 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
17439 if(!isWasmInitialized) {
17440 throw new Error("initializeWasm() must be awaited first!");
17442 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
17443 return nativeResponseValue;
17445 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
17447 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
17448 if(!isWasmInitialized) {
17449 throw new Error("initializeWasm() must be awaited first!");
17451 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
17452 return nativeResponseValue;
17454 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
17456 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
17457 if(!isWasmInitialized) {
17458 throw new Error("initializeWasm() must be awaited first!");
17460 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
17461 return nativeResponseValue;
17463 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
17465 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
17466 if(!isWasmInitialized) {
17467 throw new Error("initializeWasm() must be awaited first!");
17469 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
17470 return nativeResponseValue;
17472 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
17474 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
17475 if(!isWasmInitialized) {
17476 throw new Error("initializeWasm() must be awaited first!");
17478 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
17479 // debug statements here
17481 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
17483 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
17484 if(!isWasmInitialized) {
17485 throw new Error("initializeWasm() must be awaited first!");
17487 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
17488 return nativeResponseValue;
17490 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
17492 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
17493 if(!isWasmInitialized) {
17494 throw new Error("initializeWasm() must be awaited first!");
17496 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
17497 return nativeResponseValue;
17499 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
17501 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
17502 if(!isWasmInitialized) {
17503 throw new Error("initializeWasm() must be awaited first!");
17505 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
17506 return nativeResponseValue;
17508 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
17510 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
17511 if(!isWasmInitialized) {
17512 throw new Error("initializeWasm() must be awaited first!");
17514 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
17515 return nativeResponseValue;
17517 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
17519 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
17520 if(!isWasmInitialized) {
17521 throw new Error("initializeWasm() must be awaited first!");
17523 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
17524 return nativeResponseValue;
17526 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
17528 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
17529 if(!isWasmInitialized) {
17530 throw new Error("initializeWasm() must be awaited first!");
17532 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
17533 // debug statements here
17535 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
17537 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
17538 if(!isWasmInitialized) {
17539 throw new Error("initializeWasm() must be awaited first!");
17541 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
17542 return nativeResponseValue;
17544 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
17546 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
17547 if(!isWasmInitialized) {
17548 throw new Error("initializeWasm() must be awaited first!");
17550 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
17551 return nativeResponseValue;
17553 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
17555 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
17556 if(!isWasmInitialized) {
17557 throw new Error("initializeWasm() must be awaited first!");
17559 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
17560 // debug statements here
17562 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
17564 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
17565 if(!isWasmInitialized) {
17566 throw new Error("initializeWasm() must be awaited first!");
17568 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
17569 return nativeResponseValue;
17571 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
17573 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
17574 if(!isWasmInitialized) {
17575 throw new Error("initializeWasm() must be awaited first!");
17577 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
17578 return nativeResponseValue;
17580 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
17582 export function CVec_MessageSendEventZ_free(_res: number): void {
17583 if(!isWasmInitialized) {
17584 throw new Error("initializeWasm() must be awaited first!");
17586 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
17587 // debug statements here
17589 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
17591 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
17592 if(!isWasmInitialized) {
17593 throw new Error("initializeWasm() must be awaited first!");
17595 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
17596 return nativeResponseValue;
17598 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
17600 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
17601 if(!isWasmInitialized) {
17602 throw new Error("initializeWasm() must be awaited first!");
17604 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
17605 return nativeResponseValue;
17607 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
17609 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17610 if(!isWasmInitialized) {
17611 throw new Error("initializeWasm() must be awaited first!");
17613 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
17614 return nativeResponseValue;
17616 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
17618 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
17619 if(!isWasmInitialized) {
17620 throw new Error("initializeWasm() must be awaited first!");
17622 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
17623 // debug statements here
17625 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
17627 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17628 if(!isWasmInitialized) {
17629 throw new Error("initializeWasm() must be awaited first!");
17631 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
17632 return nativeResponseValue;
17634 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
17636 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
17637 if(!isWasmInitialized) {
17638 throw new Error("initializeWasm() must be awaited first!");
17640 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
17641 return nativeResponseValue;
17643 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
17645 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
17646 if(!isWasmInitialized) {
17647 throw new Error("initializeWasm() must be awaited first!");
17649 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
17650 return nativeResponseValue;
17652 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
17654 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
17655 if(!isWasmInitialized) {
17656 throw new Error("initializeWasm() must be awaited first!");
17658 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
17659 return nativeResponseValue;
17661 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
17663 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17664 if(!isWasmInitialized) {
17665 throw new Error("initializeWasm() must be awaited first!");
17667 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
17668 return nativeResponseValue;
17670 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
17672 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
17673 if(!isWasmInitialized) {
17674 throw new Error("initializeWasm() must be awaited first!");
17676 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
17677 // debug statements here
17679 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
17681 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17682 if(!isWasmInitialized) {
17683 throw new Error("initializeWasm() must be awaited first!");
17685 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
17686 return nativeResponseValue;
17688 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
17690 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
17691 if(!isWasmInitialized) {
17692 throw new Error("initializeWasm() must be awaited first!");
17694 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
17695 return nativeResponseValue;
17697 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
17699 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
17700 if(!isWasmInitialized) {
17701 throw new Error("initializeWasm() must be awaited first!");
17703 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
17704 return nativeResponseValue;
17706 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
17708 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
17709 if(!isWasmInitialized) {
17710 throw new Error("initializeWasm() must be awaited first!");
17712 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
17713 return nativeResponseValue;
17715 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
17717 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
17718 if(!isWasmInitialized) {
17719 throw new Error("initializeWasm() must be awaited first!");
17721 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
17722 return nativeResponseValue;
17724 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
17726 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
17727 if(!isWasmInitialized) {
17728 throw new Error("initializeWasm() must be awaited first!");
17730 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
17731 // debug statements here
17733 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
17735 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17736 if(!isWasmInitialized) {
17737 throw new Error("initializeWasm() must be awaited first!");
17739 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
17740 return nativeResponseValue;
17742 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
17744 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
17745 if(!isWasmInitialized) {
17746 throw new Error("initializeWasm() must be awaited first!");
17748 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
17749 return nativeResponseValue;
17751 // void CVec_SocketAddressZ_free(struct LDKCVec_SocketAddressZ _res);
17753 export function CVec_SocketAddressZ_free(_res: number): void {
17754 if(!isWasmInitialized) {
17755 throw new Error("initializeWasm() must be awaited first!");
17757 const nativeResponseValue = wasm.TS_CVec_SocketAddressZ_free(_res);
17758 // debug statements here
17760 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
17762 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
17763 if(!isWasmInitialized) {
17764 throw new Error("initializeWasm() must be awaited first!");
17766 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
17767 return nativeResponseValue;
17769 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
17771 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
17772 if(!isWasmInitialized) {
17773 throw new Error("initializeWasm() must be awaited first!");
17775 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
17776 return nativeResponseValue;
17778 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
17780 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17781 if(!isWasmInitialized) {
17782 throw new Error("initializeWasm() must be awaited first!");
17784 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
17785 return nativeResponseValue;
17787 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
17789 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
17790 if(!isWasmInitialized) {
17791 throw new Error("initializeWasm() must be awaited first!");
17793 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
17794 // debug statements here
17796 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
17798 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17799 if(!isWasmInitialized) {
17800 throw new Error("initializeWasm() must be awaited first!");
17802 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
17803 return nativeResponseValue;
17805 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
17807 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
17808 if(!isWasmInitialized) {
17809 throw new Error("initializeWasm() must be awaited first!");
17811 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
17812 return nativeResponseValue;
17814 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
17816 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
17817 if(!isWasmInitialized) {
17818 throw new Error("initializeWasm() must be awaited first!");
17820 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
17821 return nativeResponseValue;
17823 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
17825 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
17826 if(!isWasmInitialized) {
17827 throw new Error("initializeWasm() must be awaited first!");
17829 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
17830 return nativeResponseValue;
17832 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
17834 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
17835 if(!isWasmInitialized) {
17836 throw new Error("initializeWasm() must be awaited first!");
17838 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
17839 return nativeResponseValue;
17841 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
17843 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
17844 if(!isWasmInitialized) {
17845 throw new Error("initializeWasm() must be awaited first!");
17847 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
17848 // debug statements here
17850 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
17852 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17853 if(!isWasmInitialized) {
17854 throw new Error("initializeWasm() must be awaited first!");
17856 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
17857 return nativeResponseValue;
17859 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
17861 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
17862 if(!isWasmInitialized) {
17863 throw new Error("initializeWasm() must be awaited first!");
17865 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
17866 return nativeResponseValue;
17868 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
17870 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
17871 if(!isWasmInitialized) {
17872 throw new Error("initializeWasm() must be awaited first!");
17874 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
17875 return nativeResponseValue;
17877 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
17879 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
17880 if(!isWasmInitialized) {
17881 throw new Error("initializeWasm() must be awaited first!");
17883 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
17884 return nativeResponseValue;
17886 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
17888 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17889 if(!isWasmInitialized) {
17890 throw new Error("initializeWasm() must be awaited first!");
17892 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
17893 return nativeResponseValue;
17895 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
17897 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
17898 if(!isWasmInitialized) {
17899 throw new Error("initializeWasm() must be awaited first!");
17901 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
17902 // debug statements here
17904 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
17906 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17907 if(!isWasmInitialized) {
17908 throw new Error("initializeWasm() must be awaited first!");
17910 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
17911 return nativeResponseValue;
17913 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
17915 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
17916 if(!isWasmInitialized) {
17917 throw new Error("initializeWasm() must be awaited first!");
17919 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
17920 return nativeResponseValue;
17922 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
17924 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
17925 if(!isWasmInitialized) {
17926 throw new Error("initializeWasm() must be awaited first!");
17928 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
17929 return nativeResponseValue;
17931 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
17933 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
17934 if(!isWasmInitialized) {
17935 throw new Error("initializeWasm() must be awaited first!");
17937 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
17938 return nativeResponseValue;
17940 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
17942 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
17943 if(!isWasmInitialized) {
17944 throw new Error("initializeWasm() must be awaited first!");
17946 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
17947 return nativeResponseValue;
17949 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
17951 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
17952 if(!isWasmInitialized) {
17953 throw new Error("initializeWasm() must be awaited first!");
17955 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
17956 // debug statements here
17958 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_some(struct LDKCVec_SocketAddressZ o);
17960 export function COption_CVec_SocketAddressZZ_some(o: number): bigint {
17961 if(!isWasmInitialized) {
17962 throw new Error("initializeWasm() must be awaited first!");
17964 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_some(o);
17965 return nativeResponseValue;
17967 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_none(void);
17969 export function COption_CVec_SocketAddressZZ_none(): bigint {
17970 if(!isWasmInitialized) {
17971 throw new Error("initializeWasm() must be awaited first!");
17973 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_none();
17974 return nativeResponseValue;
17976 // void COption_CVec_SocketAddressZZ_free(struct LDKCOption_CVec_SocketAddressZZ _res);
17978 export function COption_CVec_SocketAddressZZ_free(_res: bigint): void {
17979 if(!isWasmInitialized) {
17980 throw new Error("initializeWasm() must be awaited first!");
17982 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_free(_res);
17983 // debug statements here
17985 // uint64_t COption_CVec_SocketAddressZZ_clone_ptr(LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR arg);
17987 export function COption_CVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
17988 if(!isWasmInitialized) {
17989 throw new Error("initializeWasm() must be awaited first!");
17991 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone_ptr(arg);
17992 return nativeResponseValue;
17994 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_clone(const struct LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR orig);
17996 export function COption_CVec_SocketAddressZZ_clone(orig: bigint): bigint {
17997 if(!isWasmInitialized) {
17998 throw new Error("initializeWasm() must be awaited first!");
18000 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone(orig);
18001 return nativeResponseValue;
18003 // struct LDKCResult_u64ShortChannelIdErrorZ CResult_u64ShortChannelIdErrorZ_ok(uint64_t o);
18005 export function CResult_u64ShortChannelIdErrorZ_ok(o: bigint): bigint {
18006 if(!isWasmInitialized) {
18007 throw new Error("initializeWasm() must be awaited first!");
18009 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_ok(o);
18010 return nativeResponseValue;
18012 // struct LDKCResult_u64ShortChannelIdErrorZ CResult_u64ShortChannelIdErrorZ_err(enum LDKShortChannelIdError e);
18014 export function CResult_u64ShortChannelIdErrorZ_err(e: ShortChannelIdError): bigint {
18015 if(!isWasmInitialized) {
18016 throw new Error("initializeWasm() must be awaited first!");
18018 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_err(e);
18019 return nativeResponseValue;
18021 // bool CResult_u64ShortChannelIdErrorZ_is_ok(const struct LDKCResult_u64ShortChannelIdErrorZ *NONNULL_PTR o);
18023 export function CResult_u64ShortChannelIdErrorZ_is_ok(o: bigint): boolean {
18024 if(!isWasmInitialized) {
18025 throw new Error("initializeWasm() must be awaited first!");
18027 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_is_ok(o);
18028 return nativeResponseValue;
18030 // void CResult_u64ShortChannelIdErrorZ_free(struct LDKCResult_u64ShortChannelIdErrorZ _res);
18032 export function CResult_u64ShortChannelIdErrorZ_free(_res: bigint): void {
18033 if(!isWasmInitialized) {
18034 throw new Error("initializeWasm() must be awaited first!");
18036 const nativeResponseValue = wasm.TS_CResult_u64ShortChannelIdErrorZ_free(_res);
18037 // debug statements here
18039 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ CResult_PendingHTLCInfoInboundHTLCErrZ_ok(struct LDKPendingHTLCInfo o);
18041 export function CResult_PendingHTLCInfoInboundHTLCErrZ_ok(o: bigint): bigint {
18042 if(!isWasmInitialized) {
18043 throw new Error("initializeWasm() must be awaited first!");
18045 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_ok(o);
18046 return nativeResponseValue;
18048 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ CResult_PendingHTLCInfoInboundHTLCErrZ_err(struct LDKInboundHTLCErr e);
18050 export function CResult_PendingHTLCInfoInboundHTLCErrZ_err(e: bigint): bigint {
18051 if(!isWasmInitialized) {
18052 throw new Error("initializeWasm() must be awaited first!");
18054 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_err(e);
18055 return nativeResponseValue;
18057 // bool CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(const struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR o);
18059 export function CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(o: bigint): boolean {
18060 if(!isWasmInitialized) {
18061 throw new Error("initializeWasm() must be awaited first!");
18063 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(o);
18064 return nativeResponseValue;
18066 // void CResult_PendingHTLCInfoInboundHTLCErrZ_free(struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ _res);
18068 export function CResult_PendingHTLCInfoInboundHTLCErrZ_free(_res: bigint): void {
18069 if(!isWasmInitialized) {
18070 throw new Error("initializeWasm() must be awaited first!");
18072 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_free(_res);
18073 // debug statements here
18075 // uint64_t CResult_PendingHTLCInfoInboundHTLCErrZ_clone_ptr(LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR arg);
18077 export function CResult_PendingHTLCInfoInboundHTLCErrZ_clone_ptr(arg: bigint): bigint {
18078 if(!isWasmInitialized) {
18079 throw new Error("initializeWasm() must be awaited first!");
18081 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_clone_ptr(arg);
18082 return nativeResponseValue;
18084 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ CResult_PendingHTLCInfoInboundHTLCErrZ_clone(const struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR orig);
18086 export function CResult_PendingHTLCInfoInboundHTLCErrZ_clone(orig: bigint): bigint {
18087 if(!isWasmInitialized) {
18088 throw new Error("initializeWasm() must be awaited first!");
18090 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_clone(orig);
18091 return nativeResponseValue;
18093 // void CVec_HTLCOutputInCommitmentZ_free(struct LDKCVec_HTLCOutputInCommitmentZ _res);
18095 export function CVec_HTLCOutputInCommitmentZ_free(_res: number): void {
18096 if(!isWasmInitialized) {
18097 throw new Error("initializeWasm() must be awaited first!");
18099 const nativeResponseValue = wasm.TS_CVec_HTLCOutputInCommitmentZ_free(_res);
18100 // debug statements here
18102 // void CVec_HTLCDescriptorZ_free(struct LDKCVec_HTLCDescriptorZ _res);
18104 export function CVec_HTLCDescriptorZ_free(_res: number): void {
18105 if(!isWasmInitialized) {
18106 throw new Error("initializeWasm() must be awaited first!");
18108 const nativeResponseValue = wasm.TS_CVec_HTLCDescriptorZ_free(_res);
18109 // debug statements here
18111 // void CVec_UtxoZ_free(struct LDKCVec_UtxoZ _res);
18113 export function CVec_UtxoZ_free(_res: number): void {
18114 if(!isWasmInitialized) {
18115 throw new Error("initializeWasm() must be awaited first!");
18117 const nativeResponseValue = wasm.TS_CVec_UtxoZ_free(_res);
18118 // debug statements here
18120 // struct LDKCOption_TxOutZ COption_TxOutZ_some(struct LDKTxOut o);
18122 export function COption_TxOutZ_some(o: bigint): bigint {
18123 if(!isWasmInitialized) {
18124 throw new Error("initializeWasm() must be awaited first!");
18126 const nativeResponseValue = wasm.TS_COption_TxOutZ_some(o);
18127 return nativeResponseValue;
18129 // struct LDKCOption_TxOutZ COption_TxOutZ_none(void);
18131 export function COption_TxOutZ_none(): bigint {
18132 if(!isWasmInitialized) {
18133 throw new Error("initializeWasm() must be awaited first!");
18135 const nativeResponseValue = wasm.TS_COption_TxOutZ_none();
18136 return nativeResponseValue;
18138 // void COption_TxOutZ_free(struct LDKCOption_TxOutZ _res);
18140 export function COption_TxOutZ_free(_res: bigint): void {
18141 if(!isWasmInitialized) {
18142 throw new Error("initializeWasm() must be awaited first!");
18144 const nativeResponseValue = wasm.TS_COption_TxOutZ_free(_res);
18145 // debug statements here
18147 // uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg);
18149 export function COption_TxOutZ_clone_ptr(arg: bigint): bigint {
18150 if(!isWasmInitialized) {
18151 throw new Error("initializeWasm() must be awaited first!");
18153 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone_ptr(arg);
18154 return nativeResponseValue;
18156 // struct LDKCOption_TxOutZ COption_TxOutZ_clone(const struct LDKCOption_TxOutZ *NONNULL_PTR orig);
18158 export function COption_TxOutZ_clone(orig: bigint): bigint {
18159 if(!isWasmInitialized) {
18160 throw new Error("initializeWasm() must be awaited first!");
18162 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone(orig);
18163 return nativeResponseValue;
18165 // void CVec_InputZ_free(struct LDKCVec_InputZ _res);
18167 export function CVec_InputZ_free(_res: number): void {
18168 if(!isWasmInitialized) {
18169 throw new Error("initializeWasm() must be awaited first!");
18171 const nativeResponseValue = wasm.TS_CVec_InputZ_free(_res);
18172 // debug statements here
18174 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_ok(struct LDKCoinSelection o);
18176 export function CResult_CoinSelectionNoneZ_ok(o: bigint): bigint {
18177 if(!isWasmInitialized) {
18178 throw new Error("initializeWasm() must be awaited first!");
18180 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_ok(o);
18181 return nativeResponseValue;
18183 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_err(void);
18185 export function CResult_CoinSelectionNoneZ_err(): bigint {
18186 if(!isWasmInitialized) {
18187 throw new Error("initializeWasm() must be awaited first!");
18189 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_err();
18190 return nativeResponseValue;
18192 // bool CResult_CoinSelectionNoneZ_is_ok(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR o);
18194 export function CResult_CoinSelectionNoneZ_is_ok(o: bigint): boolean {
18195 if(!isWasmInitialized) {
18196 throw new Error("initializeWasm() must be awaited first!");
18198 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_is_ok(o);
18199 return nativeResponseValue;
18201 // void CResult_CoinSelectionNoneZ_free(struct LDKCResult_CoinSelectionNoneZ _res);
18203 export function CResult_CoinSelectionNoneZ_free(_res: bigint): void {
18204 if(!isWasmInitialized) {
18205 throw new Error("initializeWasm() must be awaited first!");
18207 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_free(_res);
18208 // debug statements here
18210 // uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg);
18212 export function CResult_CoinSelectionNoneZ_clone_ptr(arg: bigint): bigint {
18213 if(!isWasmInitialized) {
18214 throw new Error("initializeWasm() must be awaited first!");
18216 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone_ptr(arg);
18217 return nativeResponseValue;
18219 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_clone(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR orig);
18221 export function CResult_CoinSelectionNoneZ_clone(orig: bigint): bigint {
18222 if(!isWasmInitialized) {
18223 throw new Error("initializeWasm() must be awaited first!");
18225 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone(orig);
18226 return nativeResponseValue;
18228 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_ok(struct LDKCVec_UtxoZ o);
18230 export function CResult_CVec_UtxoZNoneZ_ok(o: number): bigint {
18231 if(!isWasmInitialized) {
18232 throw new Error("initializeWasm() must be awaited first!");
18234 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_ok(o);
18235 return nativeResponseValue;
18237 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_err(void);
18239 export function CResult_CVec_UtxoZNoneZ_err(): bigint {
18240 if(!isWasmInitialized) {
18241 throw new Error("initializeWasm() must be awaited first!");
18243 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_err();
18244 return nativeResponseValue;
18246 // bool CResult_CVec_UtxoZNoneZ_is_ok(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR o);
18248 export function CResult_CVec_UtxoZNoneZ_is_ok(o: bigint): boolean {
18249 if(!isWasmInitialized) {
18250 throw new Error("initializeWasm() must be awaited first!");
18252 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_is_ok(o);
18253 return nativeResponseValue;
18255 // void CResult_CVec_UtxoZNoneZ_free(struct LDKCResult_CVec_UtxoZNoneZ _res);
18257 export function CResult_CVec_UtxoZNoneZ_free(_res: bigint): void {
18258 if(!isWasmInitialized) {
18259 throw new Error("initializeWasm() must be awaited first!");
18261 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_free(_res);
18262 // debug statements here
18264 // uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg);
18266 export function CResult_CVec_UtxoZNoneZ_clone_ptr(arg: bigint): bigint {
18267 if(!isWasmInitialized) {
18268 throw new Error("initializeWasm() must be awaited first!");
18270 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone_ptr(arg);
18271 return nativeResponseValue;
18273 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_clone(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR orig);
18275 export function CResult_CVec_UtxoZNoneZ_clone(orig: bigint): bigint {
18276 if(!isWasmInitialized) {
18277 throw new Error("initializeWasm() must be awaited first!");
18279 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone(orig);
18280 return nativeResponseValue;
18282 // struct LDKCOption_PaymentContextZ COption_PaymentContextZ_some(struct LDKPaymentContext o);
18284 export function COption_PaymentContextZ_some(o: bigint): bigint {
18285 if(!isWasmInitialized) {
18286 throw new Error("initializeWasm() must be awaited first!");
18288 const nativeResponseValue = wasm.TS_COption_PaymentContextZ_some(o);
18289 return nativeResponseValue;
18291 // struct LDKCOption_PaymentContextZ COption_PaymentContextZ_none(void);
18293 export function COption_PaymentContextZ_none(): bigint {
18294 if(!isWasmInitialized) {
18295 throw new Error("initializeWasm() must be awaited first!");
18297 const nativeResponseValue = wasm.TS_COption_PaymentContextZ_none();
18298 return nativeResponseValue;
18300 // void COption_PaymentContextZ_free(struct LDKCOption_PaymentContextZ _res);
18302 export function COption_PaymentContextZ_free(_res: bigint): void {
18303 if(!isWasmInitialized) {
18304 throw new Error("initializeWasm() must be awaited first!");
18306 const nativeResponseValue = wasm.TS_COption_PaymentContextZ_free(_res);
18307 // debug statements here
18309 // uint64_t COption_PaymentContextZ_clone_ptr(LDKCOption_PaymentContextZ *NONNULL_PTR arg);
18311 export function COption_PaymentContextZ_clone_ptr(arg: bigint): bigint {
18312 if(!isWasmInitialized) {
18313 throw new Error("initializeWasm() must be awaited first!");
18315 const nativeResponseValue = wasm.TS_COption_PaymentContextZ_clone_ptr(arg);
18316 return nativeResponseValue;
18318 // struct LDKCOption_PaymentContextZ COption_PaymentContextZ_clone(const struct LDKCOption_PaymentContextZ *NONNULL_PTR orig);
18320 export function COption_PaymentContextZ_clone(orig: bigint): bigint {
18321 if(!isWasmInitialized) {
18322 throw new Error("initializeWasm() must be awaited first!");
18324 const nativeResponseValue = wasm.TS_COption_PaymentContextZ_clone(orig);
18325 return nativeResponseValue;
18327 // uint64_t C2Tuple_u64u16Z_clone_ptr(LDKC2Tuple_u64u16Z *NONNULL_PTR arg);
18329 export function C2Tuple_u64u16Z_clone_ptr(arg: bigint): bigint {
18330 if(!isWasmInitialized) {
18331 throw new Error("initializeWasm() must be awaited first!");
18333 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone_ptr(arg);
18334 return nativeResponseValue;
18336 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_clone(const struct LDKC2Tuple_u64u16Z *NONNULL_PTR orig);
18338 export function C2Tuple_u64u16Z_clone(orig: bigint): bigint {
18339 if(!isWasmInitialized) {
18340 throw new Error("initializeWasm() must be awaited first!");
18342 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone(orig);
18343 return nativeResponseValue;
18345 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_new(uint64_t a, uint16_t b);
18347 export function C2Tuple_u64u16Z_new(a: bigint, b: number): bigint {
18348 if(!isWasmInitialized) {
18349 throw new Error("initializeWasm() must be awaited first!");
18351 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_new(a, b);
18352 return nativeResponseValue;
18354 // void C2Tuple_u64u16Z_free(struct LDKC2Tuple_u64u16Z _res);
18356 export function C2Tuple_u64u16Z_free(_res: bigint): void {
18357 if(!isWasmInitialized) {
18358 throw new Error("initializeWasm() must be awaited first!");
18360 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_free(_res);
18361 // debug statements here
18363 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_some(struct LDKC2Tuple_u64u16Z o);
18365 export function COption_C2Tuple_u64u16ZZ_some(o: bigint): bigint {
18366 if(!isWasmInitialized) {
18367 throw new Error("initializeWasm() must be awaited first!");
18369 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_some(o);
18370 return nativeResponseValue;
18372 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_none(void);
18374 export function COption_C2Tuple_u64u16ZZ_none(): bigint {
18375 if(!isWasmInitialized) {
18376 throw new Error("initializeWasm() must be awaited first!");
18378 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_none();
18379 return nativeResponseValue;
18381 // void COption_C2Tuple_u64u16ZZ_free(struct LDKCOption_C2Tuple_u64u16ZZ _res);
18383 export function COption_C2Tuple_u64u16ZZ_free(_res: bigint): void {
18384 if(!isWasmInitialized) {
18385 throw new Error("initializeWasm() must be awaited first!");
18387 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_free(_res);
18388 // debug statements here
18390 // uint64_t COption_C2Tuple_u64u16ZZ_clone_ptr(LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR arg);
18392 export function COption_C2Tuple_u64u16ZZ_clone_ptr(arg: bigint): bigint {
18393 if(!isWasmInitialized) {
18394 throw new Error("initializeWasm() must be awaited first!");
18396 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone_ptr(arg);
18397 return nativeResponseValue;
18399 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_clone(const struct LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR orig);
18401 export function COption_C2Tuple_u64u16ZZ_clone(orig: bigint): bigint {
18402 if(!isWasmInitialized) {
18403 throw new Error("initializeWasm() must be awaited first!");
18405 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone(orig);
18406 return nativeResponseValue;
18408 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
18410 export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
18411 if(!isWasmInitialized) {
18412 throw new Error("initializeWasm() must be awaited first!");
18414 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
18415 return nativeResponseValue;
18417 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
18419 export function COption_ChannelShutdownStateZ_none(): bigint {
18420 if(!isWasmInitialized) {
18421 throw new Error("initializeWasm() must be awaited first!");
18423 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
18424 return nativeResponseValue;
18426 // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
18428 export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
18429 if(!isWasmInitialized) {
18430 throw new Error("initializeWasm() must be awaited first!");
18432 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
18433 // debug statements here
18435 // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
18437 export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
18438 if(!isWasmInitialized) {
18439 throw new Error("initializeWasm() must be awaited first!");
18441 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
18442 return nativeResponseValue;
18444 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
18446 export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
18447 if(!isWasmInitialized) {
18448 throw new Error("initializeWasm() must be awaited first!");
18450 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
18451 return nativeResponseValue;
18453 // struct LDKCResult_ChannelIdAPIErrorZ CResult_ChannelIdAPIErrorZ_ok(struct LDKChannelId o);
18455 export function CResult_ChannelIdAPIErrorZ_ok(o: bigint): bigint {
18456 if(!isWasmInitialized) {
18457 throw new Error("initializeWasm() must be awaited first!");
18459 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_ok(o);
18460 return nativeResponseValue;
18462 // struct LDKCResult_ChannelIdAPIErrorZ CResult_ChannelIdAPIErrorZ_err(struct LDKAPIError e);
18464 export function CResult_ChannelIdAPIErrorZ_err(e: bigint): bigint {
18465 if(!isWasmInitialized) {
18466 throw new Error("initializeWasm() must be awaited first!");
18468 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_err(e);
18469 return nativeResponseValue;
18471 // bool CResult_ChannelIdAPIErrorZ_is_ok(const struct LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR o);
18473 export function CResult_ChannelIdAPIErrorZ_is_ok(o: bigint): boolean {
18474 if(!isWasmInitialized) {
18475 throw new Error("initializeWasm() must be awaited first!");
18477 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_is_ok(o);
18478 return nativeResponseValue;
18480 // void CResult_ChannelIdAPIErrorZ_free(struct LDKCResult_ChannelIdAPIErrorZ _res);
18482 export function CResult_ChannelIdAPIErrorZ_free(_res: bigint): void {
18483 if(!isWasmInitialized) {
18484 throw new Error("initializeWasm() must be awaited first!");
18486 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_free(_res);
18487 // debug statements here
18489 // uint64_t CResult_ChannelIdAPIErrorZ_clone_ptr(LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR arg);
18491 export function CResult_ChannelIdAPIErrorZ_clone_ptr(arg: bigint): bigint {
18492 if(!isWasmInitialized) {
18493 throw new Error("initializeWasm() must be awaited first!");
18495 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_clone_ptr(arg);
18496 return nativeResponseValue;
18498 // struct LDKCResult_ChannelIdAPIErrorZ CResult_ChannelIdAPIErrorZ_clone(const struct LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR orig);
18500 export function CResult_ChannelIdAPIErrorZ_clone(orig: bigint): bigint {
18501 if(!isWasmInitialized) {
18502 throw new Error("initializeWasm() must be awaited first!");
18504 const nativeResponseValue = wasm.TS_CResult_ChannelIdAPIErrorZ_clone(orig);
18505 return nativeResponseValue;
18507 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
18509 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
18510 if(!isWasmInitialized) {
18511 throw new Error("initializeWasm() must be awaited first!");
18513 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
18514 // debug statements here
18516 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
18518 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
18519 if(!isWasmInitialized) {
18520 throw new Error("initializeWasm() must be awaited first!");
18522 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
18523 return nativeResponseValue;
18525 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
18527 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
18528 if(!isWasmInitialized) {
18529 throw new Error("initializeWasm() must be awaited first!");
18531 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
18532 return nativeResponseValue;
18534 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
18536 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
18537 if(!isWasmInitialized) {
18538 throw new Error("initializeWasm() must be awaited first!");
18540 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
18541 return nativeResponseValue;
18543 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
18545 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
18546 if(!isWasmInitialized) {
18547 throw new Error("initializeWasm() must be awaited first!");
18549 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
18550 // debug statements here
18552 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
18554 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
18555 if(!isWasmInitialized) {
18556 throw new Error("initializeWasm() must be awaited first!");
18558 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
18559 return nativeResponseValue;
18561 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
18563 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
18564 if(!isWasmInitialized) {
18565 throw new Error("initializeWasm() must be awaited first!");
18567 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
18568 return nativeResponseValue;
18570 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
18572 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
18573 if(!isWasmInitialized) {
18574 throw new Error("initializeWasm() must be awaited first!");
18576 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
18577 return nativeResponseValue;
18579 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
18581 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
18582 if(!isWasmInitialized) {
18583 throw new Error("initializeWasm() must be awaited first!");
18585 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
18586 return nativeResponseValue;
18588 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
18590 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
18591 if(!isWasmInitialized) {
18592 throw new Error("initializeWasm() must be awaited first!");
18594 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
18595 return nativeResponseValue;
18597 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
18599 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
18600 if(!isWasmInitialized) {
18601 throw new Error("initializeWasm() must be awaited first!");
18603 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
18604 // debug statements here
18606 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
18608 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
18609 if(!isWasmInitialized) {
18610 throw new Error("initializeWasm() must be awaited first!");
18612 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
18613 return nativeResponseValue;
18615 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
18617 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
18618 if(!isWasmInitialized) {
18619 throw new Error("initializeWasm() must be awaited first!");
18621 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
18622 return nativeResponseValue;
18624 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
18626 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o: number): bigint {
18627 if(!isWasmInitialized) {
18628 throw new Error("initializeWasm() must be awaited first!");
18630 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o);
18631 return nativeResponseValue;
18633 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
18635 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e: bigint): bigint {
18636 if(!isWasmInitialized) {
18637 throw new Error("initializeWasm() must be awaited first!");
18639 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e);
18640 return nativeResponseValue;
18642 // bool CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR o);
18644 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o: bigint): boolean {
18645 if(!isWasmInitialized) {
18646 throw new Error("initializeWasm() must be awaited first!");
18648 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o);
18649 return nativeResponseValue;
18651 // void CResult_ThirtyTwoBytesPaymentSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ _res);
18653 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res: bigint): void {
18654 if(!isWasmInitialized) {
18655 throw new Error("initializeWasm() must be awaited first!");
18657 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res);
18658 // debug statements here
18660 // uint64_t CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR arg);
18662 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
18663 if(!isWasmInitialized) {
18664 throw new Error("initializeWasm() must be awaited first!");
18666 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg);
18667 return nativeResponseValue;
18669 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR orig);
18671 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig: bigint): bigint {
18672 if(!isWasmInitialized) {
18673 throw new Error("initializeWasm() must be awaited first!");
18675 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig);
18676 return nativeResponseValue;
18678 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
18680 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o: number): bigint {
18681 if(!isWasmInitialized) {
18682 throw new Error("initializeWasm() must be awaited first!");
18684 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o);
18685 return nativeResponseValue;
18687 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
18689 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
18690 if(!isWasmInitialized) {
18691 throw new Error("initializeWasm() must be awaited first!");
18693 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e);
18694 return nativeResponseValue;
18696 // bool CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR o);
18698 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o: bigint): boolean {
18699 if(!isWasmInitialized) {
18700 throw new Error("initializeWasm() must be awaited first!");
18702 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o);
18703 return nativeResponseValue;
18705 // void CResult_ThirtyTwoBytesRetryableSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ _res);
18707 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res: bigint): void {
18708 if(!isWasmInitialized) {
18709 throw new Error("initializeWasm() must be awaited first!");
18711 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res);
18712 // debug statements here
18714 // uint64_t CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR arg);
18716 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
18717 if(!isWasmInitialized) {
18718 throw new Error("initializeWasm() must be awaited first!");
18720 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg);
18721 return nativeResponseValue;
18723 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR orig);
18725 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig: bigint): bigint {
18726 if(!isWasmInitialized) {
18727 throw new Error("initializeWasm() must be awaited first!");
18729 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig);
18730 return nativeResponseValue;
18732 // uint64_t C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR arg);
18734 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
18735 if(!isWasmInitialized) {
18736 throw new Error("initializeWasm() must be awaited first!");
18738 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg);
18739 return nativeResponseValue;
18741 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR orig);
18743 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig: bigint): bigint {
18744 if(!isWasmInitialized) {
18745 throw new Error("initializeWasm() must be awaited first!");
18747 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig);
18748 return nativeResponseValue;
18750 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
18752 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a: number, b: number): bigint {
18753 if(!isWasmInitialized) {
18754 throw new Error("initializeWasm() must be awaited first!");
18756 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a, b);
18757 return nativeResponseValue;
18759 // void C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res);
18761 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res: bigint): void {
18762 if(!isWasmInitialized) {
18763 throw new Error("initializeWasm() must be awaited first!");
18765 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res);
18766 // debug statements here
18768 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
18770 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o: bigint): bigint {
18771 if(!isWasmInitialized) {
18772 throw new Error("initializeWasm() must be awaited first!");
18774 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o);
18775 return nativeResponseValue;
18777 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
18779 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e: bigint): bigint {
18780 if(!isWasmInitialized) {
18781 throw new Error("initializeWasm() must be awaited first!");
18783 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e);
18784 return nativeResponseValue;
18786 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR o);
18788 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o: bigint): boolean {
18789 if(!isWasmInitialized) {
18790 throw new Error("initializeWasm() must be awaited first!");
18792 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o);
18793 return nativeResponseValue;
18795 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ _res);
18797 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res: bigint): void {
18798 if(!isWasmInitialized) {
18799 throw new Error("initializeWasm() must be awaited first!");
18801 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res);
18802 // debug statements here
18804 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR arg);
18806 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
18807 if(!isWasmInitialized) {
18808 throw new Error("initializeWasm() must be awaited first!");
18810 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg);
18811 return nativeResponseValue;
18813 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR orig);
18815 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig: bigint): bigint {
18816 if(!isWasmInitialized) {
18817 throw new Error("initializeWasm() must be awaited first!");
18819 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig);
18820 return nativeResponseValue;
18822 // void CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ _res);
18824 export function CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res: number): void {
18825 if(!isWasmInitialized) {
18826 throw new Error("initializeWasm() must be awaited first!");
18828 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res);
18829 // debug statements here
18831 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
18833 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o: number): bigint {
18834 if(!isWasmInitialized) {
18835 throw new Error("initializeWasm() must be awaited first!");
18837 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o);
18838 return nativeResponseValue;
18840 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(struct LDKProbeSendFailure e);
18842 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e: bigint): bigint {
18843 if(!isWasmInitialized) {
18844 throw new Error("initializeWasm() must be awaited first!");
18846 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e);
18847 return nativeResponseValue;
18849 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR o);
18851 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o: bigint): boolean {
18852 if(!isWasmInitialized) {
18853 throw new Error("initializeWasm() must be awaited first!");
18855 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o);
18856 return nativeResponseValue;
18858 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ _res);
18860 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res: bigint): void {
18861 if(!isWasmInitialized) {
18862 throw new Error("initializeWasm() must be awaited first!");
18864 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res);
18865 // debug statements here
18867 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR arg);
18869 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg: bigint): bigint {
18870 if(!isWasmInitialized) {
18871 throw new Error("initializeWasm() must be awaited first!");
18873 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg);
18874 return nativeResponseValue;
18876 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR orig);
18878 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig: bigint): bigint {
18879 if(!isWasmInitialized) {
18880 throw new Error("initializeWasm() must be awaited first!");
18882 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig);
18883 return nativeResponseValue;
18885 // uint64_t C2Tuple_ChannelIdPublicKeyZ_clone_ptr(LDKC2Tuple_ChannelIdPublicKeyZ *NONNULL_PTR arg);
18887 export function C2Tuple_ChannelIdPublicKeyZ_clone_ptr(arg: bigint): bigint {
18888 if(!isWasmInitialized) {
18889 throw new Error("initializeWasm() must be awaited first!");
18891 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_clone_ptr(arg);
18892 return nativeResponseValue;
18894 // struct LDKC2Tuple_ChannelIdPublicKeyZ C2Tuple_ChannelIdPublicKeyZ_clone(const struct LDKC2Tuple_ChannelIdPublicKeyZ *NONNULL_PTR orig);
18896 export function C2Tuple_ChannelIdPublicKeyZ_clone(orig: bigint): bigint {
18897 if(!isWasmInitialized) {
18898 throw new Error("initializeWasm() must be awaited first!");
18900 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_clone(orig);
18901 return nativeResponseValue;
18903 // struct LDKC2Tuple_ChannelIdPublicKeyZ C2Tuple_ChannelIdPublicKeyZ_new(struct LDKChannelId a, struct LDKPublicKey b);
18905 export function C2Tuple_ChannelIdPublicKeyZ_new(a: bigint, b: number): bigint {
18906 if(!isWasmInitialized) {
18907 throw new Error("initializeWasm() must be awaited first!");
18909 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_new(a, b);
18910 return nativeResponseValue;
18912 // void C2Tuple_ChannelIdPublicKeyZ_free(struct LDKC2Tuple_ChannelIdPublicKeyZ _res);
18914 export function C2Tuple_ChannelIdPublicKeyZ_free(_res: bigint): void {
18915 if(!isWasmInitialized) {
18916 throw new Error("initializeWasm() must be awaited first!");
18918 const nativeResponseValue = wasm.TS_C2Tuple_ChannelIdPublicKeyZ_free(_res);
18919 // debug statements here
18921 // void CVec_C2Tuple_ChannelIdPublicKeyZZ_free(struct LDKCVec_C2Tuple_ChannelIdPublicKeyZZ _res);
18923 export function CVec_C2Tuple_ChannelIdPublicKeyZZ_free(_res: number): void {
18924 if(!isWasmInitialized) {
18925 throw new Error("initializeWasm() must be awaited first!");
18927 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ChannelIdPublicKeyZZ_free(_res);
18928 // debug statements here
18930 // void CVec_ChannelIdZ_free(struct LDKCVec_ChannelIdZ _res);
18932 export function CVec_ChannelIdZ_free(_res: number): void {
18933 if(!isWasmInitialized) {
18934 throw new Error("initializeWasm() must be awaited first!");
18936 const nativeResponseValue = wasm.TS_CVec_ChannelIdZ_free(_res);
18937 // debug statements here
18939 // struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(struct LDKOfferWithDerivedMetadataBuilder o);
18941 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
18942 if(!isWasmInitialized) {
18943 throw new Error("initializeWasm() must be awaited first!");
18945 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_ok(o);
18946 return nativeResponseValue;
18948 // struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
18950 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
18951 if(!isWasmInitialized) {
18952 throw new Error("initializeWasm() must be awaited first!");
18954 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_err(e);
18955 return nativeResponseValue;
18957 // bool CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
18959 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
18960 if(!isWasmInitialized) {
18961 throw new Error("initializeWasm() must be awaited first!");
18963 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_is_ok(o);
18964 return nativeResponseValue;
18966 // void CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ _res);
18968 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
18969 if(!isWasmInitialized) {
18970 throw new Error("initializeWasm() must be awaited first!");
18972 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(_res);
18973 // debug statements here
18975 // uint64_t CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR arg);
18977 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
18978 if(!isWasmInitialized) {
18979 throw new Error("initializeWasm() must be awaited first!");
18981 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone_ptr(arg);
18982 return nativeResponseValue;
18984 // struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(const struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ *NONNULL_PTR orig);
18986 export function CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(orig: bigint): bigint {
18987 if(!isWasmInitialized) {
18988 throw new Error("initializeWasm() must be awaited first!");
18990 const nativeResponseValue = wasm.TS_CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_clone(orig);
18991 return nativeResponseValue;
18993 // struct LDKCOption_StrZ COption_StrZ_some(struct LDKStr o);
18995 export function COption_StrZ_some(o: number): bigint {
18996 if(!isWasmInitialized) {
18997 throw new Error("initializeWasm() must be awaited first!");
18999 const nativeResponseValue = wasm.TS_COption_StrZ_some(o);
19000 return nativeResponseValue;
19002 // struct LDKCOption_StrZ COption_StrZ_none(void);
19004 export function COption_StrZ_none(): bigint {
19005 if(!isWasmInitialized) {
19006 throw new Error("initializeWasm() must be awaited first!");
19008 const nativeResponseValue = wasm.TS_COption_StrZ_none();
19009 return nativeResponseValue;
19011 // void COption_StrZ_free(struct LDKCOption_StrZ _res);
19013 export function COption_StrZ_free(_res: bigint): void {
19014 if(!isWasmInitialized) {
19015 throw new Error("initializeWasm() must be awaited first!");
19017 const nativeResponseValue = wasm.TS_COption_StrZ_free(_res);
19018 // debug statements here
19020 // uint64_t COption_StrZ_clone_ptr(LDKCOption_StrZ *NONNULL_PTR arg);
19022 export function COption_StrZ_clone_ptr(arg: bigint): bigint {
19023 if(!isWasmInitialized) {
19024 throw new Error("initializeWasm() must be awaited first!");
19026 const nativeResponseValue = wasm.TS_COption_StrZ_clone_ptr(arg);
19027 return nativeResponseValue;
19029 // struct LDKCOption_StrZ COption_StrZ_clone(const struct LDKCOption_StrZ *NONNULL_PTR orig);
19031 export function COption_StrZ_clone(orig: bigint): bigint {
19032 if(!isWasmInitialized) {
19033 throw new Error("initializeWasm() must be awaited first!");
19035 const nativeResponseValue = wasm.TS_COption_StrZ_clone(orig);
19036 return nativeResponseValue;
19038 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
19040 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o: bigint): bigint {
19041 if(!isWasmInitialized) {
19042 throw new Error("initializeWasm() must be awaited first!");
19044 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o);
19045 return nativeResponseValue;
19047 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(void);
19049 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(): bigint {
19050 if(!isWasmInitialized) {
19051 throw new Error("initializeWasm() must be awaited first!");
19053 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err();
19054 return nativeResponseValue;
19056 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR o);
19058 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o: bigint): boolean {
19059 if(!isWasmInitialized) {
19060 throw new Error("initializeWasm() must be awaited first!");
19062 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o);
19063 return nativeResponseValue;
19065 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ _res);
19067 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res: bigint): void {
19068 if(!isWasmInitialized) {
19069 throw new Error("initializeWasm() must be awaited first!");
19071 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res);
19072 // debug statements here
19074 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR arg);
19076 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg: bigint): bigint {
19077 if(!isWasmInitialized) {
19078 throw new Error("initializeWasm() must be awaited first!");
19080 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg);
19081 return nativeResponseValue;
19083 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR orig);
19085 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig: bigint): bigint {
19086 if(!isWasmInitialized) {
19087 throw new Error("initializeWasm() must be awaited first!");
19089 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig);
19090 return nativeResponseValue;
19092 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
19094 export function CResult_ThirtyTwoBytesAPIErrorZ_ok(o: number): bigint {
19095 if(!isWasmInitialized) {
19096 throw new Error("initializeWasm() must be awaited first!");
19098 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_ok(o);
19099 return nativeResponseValue;
19101 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_err(struct LDKAPIError e);
19103 export function CResult_ThirtyTwoBytesAPIErrorZ_err(e: bigint): bigint {
19104 if(!isWasmInitialized) {
19105 throw new Error("initializeWasm() must be awaited first!");
19107 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_err(e);
19108 return nativeResponseValue;
19110 // bool CResult_ThirtyTwoBytesAPIErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR o);
19112 export function CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o: bigint): boolean {
19113 if(!isWasmInitialized) {
19114 throw new Error("initializeWasm() must be awaited first!");
19116 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o);
19117 return nativeResponseValue;
19119 // void CResult_ThirtyTwoBytesAPIErrorZ_free(struct LDKCResult_ThirtyTwoBytesAPIErrorZ _res);
19121 export function CResult_ThirtyTwoBytesAPIErrorZ_free(_res: bigint): void {
19122 if(!isWasmInitialized) {
19123 throw new Error("initializeWasm() must be awaited first!");
19125 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_free(_res);
19126 // debug statements here
19128 // uint64_t CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR arg);
19130 export function CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg: bigint): bigint {
19131 if(!isWasmInitialized) {
19132 throw new Error("initializeWasm() must be awaited first!");
19134 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg);
19135 return nativeResponseValue;
19137 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR orig);
19139 export function CResult_ThirtyTwoBytesAPIErrorZ_clone(orig: bigint): bigint {
19140 if(!isWasmInitialized) {
19141 throw new Error("initializeWasm() must be awaited first!");
19143 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone(orig);
19144 return nativeResponseValue;
19146 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_some(struct LDKOffersMessage o);
19148 export function COption_OffersMessageZ_some(o: bigint): bigint {
19149 if(!isWasmInitialized) {
19150 throw new Error("initializeWasm() must be awaited first!");
19152 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_some(o);
19153 return nativeResponseValue;
19155 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_none(void);
19157 export function COption_OffersMessageZ_none(): bigint {
19158 if(!isWasmInitialized) {
19159 throw new Error("initializeWasm() must be awaited first!");
19161 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_none();
19162 return nativeResponseValue;
19164 // void COption_OffersMessageZ_free(struct LDKCOption_OffersMessageZ _res);
19166 export function COption_OffersMessageZ_free(_res: bigint): void {
19167 if(!isWasmInitialized) {
19168 throw new Error("initializeWasm() must be awaited first!");
19170 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_free(_res);
19171 // debug statements here
19173 // uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg);
19175 export function COption_OffersMessageZ_clone_ptr(arg: bigint): bigint {
19176 if(!isWasmInitialized) {
19177 throw new Error("initializeWasm() must be awaited first!");
19179 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone_ptr(arg);
19180 return nativeResponseValue;
19182 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_clone(const struct LDKCOption_OffersMessageZ *NONNULL_PTR orig);
19184 export function COption_OffersMessageZ_clone(orig: bigint): bigint {
19185 if(!isWasmInitialized) {
19186 throw new Error("initializeWasm() must be awaited first!");
19188 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone(orig);
19189 return nativeResponseValue;
19191 // uint64_t C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR arg);
19193 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
19194 if(!isWasmInitialized) {
19195 throw new Error("initializeWasm() must be awaited first!");
19197 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg);
19198 return nativeResponseValue;
19200 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR orig);
19202 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig: bigint): bigint {
19203 if(!isWasmInitialized) {
19204 throw new Error("initializeWasm() must be awaited first!");
19206 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig);
19207 return nativeResponseValue;
19209 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_new(struct LDKOffersMessage a, struct LDKDestination b, struct LDKBlindedPath c);
19211 export function C3Tuple_OffersMessageDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
19212 if(!isWasmInitialized) {
19213 throw new Error("initializeWasm() must be awaited first!");
19215 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_new(a, b, c);
19216 return nativeResponseValue;
19218 // void C3Tuple_OffersMessageDestinationBlindedPathZ_free(struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ _res);
19220 export function C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res: bigint): void {
19221 if(!isWasmInitialized) {
19222 throw new Error("initializeWasm() must be awaited first!");
19224 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res);
19225 // debug statements here
19227 // void CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ _res);
19229 export function CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res: number): void {
19230 if(!isWasmInitialized) {
19231 throw new Error("initializeWasm() must be awaited first!");
19233 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res);
19234 // debug statements here
19236 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
19238 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
19239 if(!isWasmInitialized) {
19240 throw new Error("initializeWasm() must be awaited first!");
19242 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
19243 return nativeResponseValue;
19245 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
19247 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
19248 if(!isWasmInitialized) {
19249 throw new Error("initializeWasm() must be awaited first!");
19251 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
19252 return nativeResponseValue;
19254 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
19256 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
19257 if(!isWasmInitialized) {
19258 throw new Error("initializeWasm() must be awaited first!");
19260 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
19261 return nativeResponseValue;
19263 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
19265 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
19266 if(!isWasmInitialized) {
19267 throw new Error("initializeWasm() must be awaited first!");
19269 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
19270 // debug statements here
19272 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
19274 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19275 if(!isWasmInitialized) {
19276 throw new Error("initializeWasm() must be awaited first!");
19278 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
19279 return nativeResponseValue;
19281 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
19283 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
19284 if(!isWasmInitialized) {
19285 throw new Error("initializeWasm() must be awaited first!");
19287 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
19288 return nativeResponseValue;
19290 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
19292 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
19293 if(!isWasmInitialized) {
19294 throw new Error("initializeWasm() must be awaited first!");
19296 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
19297 return nativeResponseValue;
19299 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
19301 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
19302 if(!isWasmInitialized) {
19303 throw new Error("initializeWasm() must be awaited first!");
19305 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
19306 return nativeResponseValue;
19308 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
19310 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
19311 if(!isWasmInitialized) {
19312 throw new Error("initializeWasm() must be awaited first!");
19314 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
19315 return nativeResponseValue;
19317 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
19319 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
19320 if(!isWasmInitialized) {
19321 throw new Error("initializeWasm() must be awaited first!");
19323 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
19324 // debug statements here
19326 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
19328 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19329 if(!isWasmInitialized) {
19330 throw new Error("initializeWasm() must be awaited first!");
19332 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
19333 return nativeResponseValue;
19335 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
19337 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
19338 if(!isWasmInitialized) {
19339 throw new Error("initializeWasm() must be awaited first!");
19341 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
19342 return nativeResponseValue;
19344 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
19346 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
19347 if(!isWasmInitialized) {
19348 throw new Error("initializeWasm() must be awaited first!");
19350 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
19351 return nativeResponseValue;
19353 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
19355 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
19356 if(!isWasmInitialized) {
19357 throw new Error("initializeWasm() must be awaited first!");
19359 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
19360 return nativeResponseValue;
19362 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
19364 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
19365 if(!isWasmInitialized) {
19366 throw new Error("initializeWasm() must be awaited first!");
19368 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
19369 return nativeResponseValue;
19371 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
19373 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
19374 if(!isWasmInitialized) {
19375 throw new Error("initializeWasm() must be awaited first!");
19377 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
19378 // debug statements here
19380 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
19382 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19383 if(!isWasmInitialized) {
19384 throw new Error("initializeWasm() must be awaited first!");
19386 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
19387 return nativeResponseValue;
19389 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
19391 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
19392 if(!isWasmInitialized) {
19393 throw new Error("initializeWasm() must be awaited first!");
19395 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
19396 return nativeResponseValue;
19398 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
19400 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
19401 if(!isWasmInitialized) {
19402 throw new Error("initializeWasm() must be awaited first!");
19404 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
19405 return nativeResponseValue;
19407 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
19409 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
19410 if(!isWasmInitialized) {
19411 throw new Error("initializeWasm() must be awaited first!");
19413 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
19414 return nativeResponseValue;
19416 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
19418 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
19419 if(!isWasmInitialized) {
19420 throw new Error("initializeWasm() must be awaited first!");
19422 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
19423 return nativeResponseValue;
19425 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
19427 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
19428 if(!isWasmInitialized) {
19429 throw new Error("initializeWasm() must be awaited first!");
19431 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
19432 // debug statements here
19434 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
19436 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19437 if(!isWasmInitialized) {
19438 throw new Error("initializeWasm() must be awaited first!");
19440 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
19441 return nativeResponseValue;
19443 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
19445 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
19446 if(!isWasmInitialized) {
19447 throw new Error("initializeWasm() must be awaited first!");
19449 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
19450 return nativeResponseValue;
19452 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_ok(struct LDKBlindedForward o);
19454 export function CResult_BlindedForwardDecodeErrorZ_ok(o: bigint): bigint {
19455 if(!isWasmInitialized) {
19456 throw new Error("initializeWasm() must be awaited first!");
19458 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_ok(o);
19459 return nativeResponseValue;
19461 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_err(struct LDKDecodeError e);
19463 export function CResult_BlindedForwardDecodeErrorZ_err(e: bigint): bigint {
19464 if(!isWasmInitialized) {
19465 throw new Error("initializeWasm() must be awaited first!");
19467 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_err(e);
19468 return nativeResponseValue;
19470 // bool CResult_BlindedForwardDecodeErrorZ_is_ok(const struct LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR o);
19472 export function CResult_BlindedForwardDecodeErrorZ_is_ok(o: bigint): boolean {
19473 if(!isWasmInitialized) {
19474 throw new Error("initializeWasm() must be awaited first!");
19476 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_is_ok(o);
19477 return nativeResponseValue;
19479 // void CResult_BlindedForwardDecodeErrorZ_free(struct LDKCResult_BlindedForwardDecodeErrorZ _res);
19481 export function CResult_BlindedForwardDecodeErrorZ_free(_res: bigint): void {
19482 if(!isWasmInitialized) {
19483 throw new Error("initializeWasm() must be awaited first!");
19485 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_free(_res);
19486 // debug statements here
19488 // uint64_t CResult_BlindedForwardDecodeErrorZ_clone_ptr(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR arg);
19490 export function CResult_BlindedForwardDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19491 if(!isWasmInitialized) {
19492 throw new Error("initializeWasm() must be awaited first!");
19494 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_clone_ptr(arg);
19495 return nativeResponseValue;
19497 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_clone(const struct LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR orig);
19499 export function CResult_BlindedForwardDecodeErrorZ_clone(orig: bigint): bigint {
19500 if(!isWasmInitialized) {
19501 throw new Error("initializeWasm() must be awaited first!");
19503 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_clone(orig);
19504 return nativeResponseValue;
19506 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_ok(struct LDKPendingHTLCRouting o);
19508 export function CResult_PendingHTLCRoutingDecodeErrorZ_ok(o: bigint): bigint {
19509 if(!isWasmInitialized) {
19510 throw new Error("initializeWasm() must be awaited first!");
19512 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_ok(o);
19513 return nativeResponseValue;
19515 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_err(struct LDKDecodeError e);
19517 export function CResult_PendingHTLCRoutingDecodeErrorZ_err(e: bigint): bigint {
19518 if(!isWasmInitialized) {
19519 throw new Error("initializeWasm() must be awaited first!");
19521 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_err(e);
19522 return nativeResponseValue;
19524 // bool CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(const struct LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR o);
19526 export function CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(o: bigint): boolean {
19527 if(!isWasmInitialized) {
19528 throw new Error("initializeWasm() must be awaited first!");
19530 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(o);
19531 return nativeResponseValue;
19533 // void CResult_PendingHTLCRoutingDecodeErrorZ_free(struct LDKCResult_PendingHTLCRoutingDecodeErrorZ _res);
19535 export function CResult_PendingHTLCRoutingDecodeErrorZ_free(_res: bigint): void {
19536 if(!isWasmInitialized) {
19537 throw new Error("initializeWasm() must be awaited first!");
19539 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_free(_res);
19540 // debug statements here
19542 // uint64_t CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR arg);
19544 export function CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19545 if(!isWasmInitialized) {
19546 throw new Error("initializeWasm() must be awaited first!");
19548 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(arg);
19549 return nativeResponseValue;
19551 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_clone(const struct LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR orig);
19553 export function CResult_PendingHTLCRoutingDecodeErrorZ_clone(orig: bigint): bigint {
19554 if(!isWasmInitialized) {
19555 throw new Error("initializeWasm() must be awaited first!");
19557 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_clone(orig);
19558 return nativeResponseValue;
19560 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_ok(struct LDKPendingHTLCInfo o);
19562 export function CResult_PendingHTLCInfoDecodeErrorZ_ok(o: bigint): bigint {
19563 if(!isWasmInitialized) {
19564 throw new Error("initializeWasm() must be awaited first!");
19566 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_ok(o);
19567 return nativeResponseValue;
19569 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_err(struct LDKDecodeError e);
19571 export function CResult_PendingHTLCInfoDecodeErrorZ_err(e: bigint): bigint {
19572 if(!isWasmInitialized) {
19573 throw new Error("initializeWasm() must be awaited first!");
19575 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_err(e);
19576 return nativeResponseValue;
19578 // bool CResult_PendingHTLCInfoDecodeErrorZ_is_ok(const struct LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR o);
19580 export function CResult_PendingHTLCInfoDecodeErrorZ_is_ok(o: bigint): boolean {
19581 if(!isWasmInitialized) {
19582 throw new Error("initializeWasm() must be awaited first!");
19584 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_is_ok(o);
19585 return nativeResponseValue;
19587 // void CResult_PendingHTLCInfoDecodeErrorZ_free(struct LDKCResult_PendingHTLCInfoDecodeErrorZ _res);
19589 export function CResult_PendingHTLCInfoDecodeErrorZ_free(_res: bigint): void {
19590 if(!isWasmInitialized) {
19591 throw new Error("initializeWasm() must be awaited first!");
19593 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_free(_res);
19594 // debug statements here
19596 // uint64_t CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR arg);
19598 export function CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19599 if(!isWasmInitialized) {
19600 throw new Error("initializeWasm() must be awaited first!");
19602 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(arg);
19603 return nativeResponseValue;
19605 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_clone(const struct LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR orig);
19607 export function CResult_PendingHTLCInfoDecodeErrorZ_clone(orig: bigint): bigint {
19608 if(!isWasmInitialized) {
19609 throw new Error("initializeWasm() must be awaited first!");
19611 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_clone(orig);
19612 return nativeResponseValue;
19614 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_ok(enum LDKBlindedFailure o);
19616 export function CResult_BlindedFailureDecodeErrorZ_ok(o: BlindedFailure): bigint {
19617 if(!isWasmInitialized) {
19618 throw new Error("initializeWasm() must be awaited first!");
19620 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_ok(o);
19621 return nativeResponseValue;
19623 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_err(struct LDKDecodeError e);
19625 export function CResult_BlindedFailureDecodeErrorZ_err(e: bigint): bigint {
19626 if(!isWasmInitialized) {
19627 throw new Error("initializeWasm() must be awaited first!");
19629 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_err(e);
19630 return nativeResponseValue;
19632 // bool CResult_BlindedFailureDecodeErrorZ_is_ok(const struct LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR o);
19634 export function CResult_BlindedFailureDecodeErrorZ_is_ok(o: bigint): boolean {
19635 if(!isWasmInitialized) {
19636 throw new Error("initializeWasm() must be awaited first!");
19638 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_is_ok(o);
19639 return nativeResponseValue;
19641 // void CResult_BlindedFailureDecodeErrorZ_free(struct LDKCResult_BlindedFailureDecodeErrorZ _res);
19643 export function CResult_BlindedFailureDecodeErrorZ_free(_res: bigint): void {
19644 if(!isWasmInitialized) {
19645 throw new Error("initializeWasm() must be awaited first!");
19647 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_free(_res);
19648 // debug statements here
19650 // uint64_t CResult_BlindedFailureDecodeErrorZ_clone_ptr(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR arg);
19652 export function CResult_BlindedFailureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19653 if(!isWasmInitialized) {
19654 throw new Error("initializeWasm() must be awaited first!");
19656 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_clone_ptr(arg);
19657 return nativeResponseValue;
19659 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_clone(const struct LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR orig);
19661 export function CResult_BlindedFailureDecodeErrorZ_clone(orig: bigint): bigint {
19662 if(!isWasmInitialized) {
19663 throw new Error("initializeWasm() must be awaited first!");
19665 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_clone(orig);
19666 return nativeResponseValue;
19668 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
19670 export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
19671 if(!isWasmInitialized) {
19672 throw new Error("initializeWasm() must be awaited first!");
19674 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
19675 return nativeResponseValue;
19677 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
19679 export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
19680 if(!isWasmInitialized) {
19681 throw new Error("initializeWasm() must be awaited first!");
19683 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
19684 return nativeResponseValue;
19686 // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
19688 export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
19689 if(!isWasmInitialized) {
19690 throw new Error("initializeWasm() must be awaited first!");
19692 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
19693 return nativeResponseValue;
19695 // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
19697 export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
19698 if(!isWasmInitialized) {
19699 throw new Error("initializeWasm() must be awaited first!");
19701 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
19702 // debug statements here
19704 // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
19706 export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19707 if(!isWasmInitialized) {
19708 throw new Error("initializeWasm() must be awaited first!");
19710 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
19711 return nativeResponseValue;
19713 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
19715 export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
19716 if(!isWasmInitialized) {
19717 throw new Error("initializeWasm() must be awaited first!");
19719 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
19720 return nativeResponseValue;
19722 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
19724 export function CVec_ChannelMonitorZ_free(_res: number): void {
19725 if(!isWasmInitialized) {
19726 throw new Error("initializeWasm() must be awaited first!");
19728 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
19729 // debug statements here
19731 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ C2Tuple_ThirtyTwoBytesChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
19733 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a: number, b: bigint): bigint {
19734 if(!isWasmInitialized) {
19735 throw new Error("initializeWasm() must be awaited first!");
19737 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a, b);
19738 return nativeResponseValue;
19740 // void C2Tuple_ThirtyTwoBytesChannelManagerZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ _res);
19742 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res: bigint): void {
19743 if(!isWasmInitialized) {
19744 throw new Error("initializeWasm() must be awaited first!");
19746 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res);
19747 // debug statements here
19749 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ o);
19751 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
19752 if(!isWasmInitialized) {
19753 throw new Error("initializeWasm() must be awaited first!");
19755 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o);
19756 return nativeResponseValue;
19758 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
19760 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
19761 if(!isWasmInitialized) {
19762 throw new Error("initializeWasm() must be awaited first!");
19764 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e);
19765 return nativeResponseValue;
19767 // bool CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR o);
19769 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
19770 if(!isWasmInitialized) {
19771 throw new Error("initializeWasm() must be awaited first!");
19773 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o);
19774 return nativeResponseValue;
19776 // void CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ _res);
19778 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res: bigint): void {
19779 if(!isWasmInitialized) {
19780 throw new Error("initializeWasm() must be awaited first!");
19782 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res);
19783 // debug statements here
19785 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_ok(struct LDKMaxDustHTLCExposure o);
19787 export function CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o: bigint): bigint {
19788 if(!isWasmInitialized) {
19789 throw new Error("initializeWasm() must be awaited first!");
19791 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o);
19792 return nativeResponseValue;
19794 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_err(struct LDKDecodeError e);
19796 export function CResult_MaxDustHTLCExposureDecodeErrorZ_err(e: bigint): bigint {
19797 if(!isWasmInitialized) {
19798 throw new Error("initializeWasm() must be awaited first!");
19800 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(e);
19801 return nativeResponseValue;
19803 // bool CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR o);
19805 export function CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o: bigint): boolean {
19806 if(!isWasmInitialized) {
19807 throw new Error("initializeWasm() must be awaited first!");
19809 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o);
19810 return nativeResponseValue;
19812 // void CResult_MaxDustHTLCExposureDecodeErrorZ_free(struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res);
19814 export function CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res: bigint): void {
19815 if(!isWasmInitialized) {
19816 throw new Error("initializeWasm() must be awaited first!");
19818 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res);
19819 // debug statements here
19821 // uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg);
19823 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19824 if(!isWasmInitialized) {
19825 throw new Error("initializeWasm() must be awaited first!");
19827 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg);
19828 return nativeResponseValue;
19830 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_clone(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR orig);
19832 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig: bigint): bigint {
19833 if(!isWasmInitialized) {
19834 throw new Error("initializeWasm() must be awaited first!");
19836 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig);
19837 return nativeResponseValue;
19839 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
19841 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
19842 if(!isWasmInitialized) {
19843 throw new Error("initializeWasm() must be awaited first!");
19845 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
19846 return nativeResponseValue;
19848 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
19850 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
19851 if(!isWasmInitialized) {
19852 throw new Error("initializeWasm() must be awaited first!");
19854 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
19855 return nativeResponseValue;
19857 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
19859 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
19860 if(!isWasmInitialized) {
19861 throw new Error("initializeWasm() must be awaited first!");
19863 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
19864 return nativeResponseValue;
19866 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
19868 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
19869 if(!isWasmInitialized) {
19870 throw new Error("initializeWasm() must be awaited first!");
19872 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
19873 // debug statements here
19875 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
19877 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19878 if(!isWasmInitialized) {
19879 throw new Error("initializeWasm() must be awaited first!");
19881 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
19882 return nativeResponseValue;
19884 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
19886 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
19887 if(!isWasmInitialized) {
19888 throw new Error("initializeWasm() must be awaited first!");
19890 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
19891 return nativeResponseValue;
19893 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_some(struct LDKMaxDustHTLCExposure o);
19895 export function COption_MaxDustHTLCExposureZ_some(o: bigint): bigint {
19896 if(!isWasmInitialized) {
19897 throw new Error("initializeWasm() must be awaited first!");
19899 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_some(o);
19900 return nativeResponseValue;
19902 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_none(void);
19904 export function COption_MaxDustHTLCExposureZ_none(): bigint {
19905 if(!isWasmInitialized) {
19906 throw new Error("initializeWasm() must be awaited first!");
19908 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_none();
19909 return nativeResponseValue;
19911 // void COption_MaxDustHTLCExposureZ_free(struct LDKCOption_MaxDustHTLCExposureZ _res);
19913 export function COption_MaxDustHTLCExposureZ_free(_res: bigint): void {
19914 if(!isWasmInitialized) {
19915 throw new Error("initializeWasm() must be awaited first!");
19917 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_free(_res);
19918 // debug statements here
19920 // uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg);
19922 export function COption_MaxDustHTLCExposureZ_clone_ptr(arg: bigint): bigint {
19923 if(!isWasmInitialized) {
19924 throw new Error("initializeWasm() must be awaited first!");
19926 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone_ptr(arg);
19927 return nativeResponseValue;
19929 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_clone(const struct LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR orig);
19931 export function COption_MaxDustHTLCExposureZ_clone(orig: bigint): bigint {
19932 if(!isWasmInitialized) {
19933 throw new Error("initializeWasm() must be awaited first!");
19935 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone(orig);
19936 return nativeResponseValue;
19938 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
19940 export function COption_APIErrorZ_some(o: bigint): bigint {
19941 if(!isWasmInitialized) {
19942 throw new Error("initializeWasm() must be awaited first!");
19944 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
19945 return nativeResponseValue;
19947 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
19949 export function COption_APIErrorZ_none(): bigint {
19950 if(!isWasmInitialized) {
19951 throw new Error("initializeWasm() must be awaited first!");
19953 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
19954 return nativeResponseValue;
19956 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
19958 export function COption_APIErrorZ_free(_res: bigint): void {
19959 if(!isWasmInitialized) {
19960 throw new Error("initializeWasm() must be awaited first!");
19962 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
19963 // debug statements here
19965 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
19967 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
19968 if(!isWasmInitialized) {
19969 throw new Error("initializeWasm() must be awaited first!");
19971 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
19972 return nativeResponseValue;
19974 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
19976 export function COption_APIErrorZ_clone(orig: bigint): bigint {
19977 if(!isWasmInitialized) {
19978 throw new Error("initializeWasm() must be awaited first!");
19980 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
19981 return nativeResponseValue;
19983 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
19985 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
19986 if(!isWasmInitialized) {
19987 throw new Error("initializeWasm() must be awaited first!");
19989 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
19990 return nativeResponseValue;
19992 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
19994 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
19995 if(!isWasmInitialized) {
19996 throw new Error("initializeWasm() must be awaited first!");
19998 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
19999 return nativeResponseValue;
20001 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
20003 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
20004 if(!isWasmInitialized) {
20005 throw new Error("initializeWasm() must be awaited first!");
20007 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
20008 return nativeResponseValue;
20010 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
20012 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
20013 if(!isWasmInitialized) {
20014 throw new Error("initializeWasm() must be awaited first!");
20016 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
20017 // debug statements here
20019 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
20021 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20022 if(!isWasmInitialized) {
20023 throw new Error("initializeWasm() must be awaited first!");
20025 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
20026 return nativeResponseValue;
20028 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
20030 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
20031 if(!isWasmInitialized) {
20032 throw new Error("initializeWasm() must be awaited first!");
20034 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
20035 return nativeResponseValue;
20037 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
20039 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
20040 if(!isWasmInitialized) {
20041 throw new Error("initializeWasm() must be awaited first!");
20043 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
20044 return nativeResponseValue;
20046 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20048 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
20049 if(!isWasmInitialized) {
20050 throw new Error("initializeWasm() must be awaited first!");
20052 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
20053 return nativeResponseValue;
20055 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
20057 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20058 if(!isWasmInitialized) {
20059 throw new Error("initializeWasm() must be awaited first!");
20061 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
20062 return nativeResponseValue;
20064 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
20066 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
20067 if(!isWasmInitialized) {
20068 throw new Error("initializeWasm() must be awaited first!");
20070 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
20071 // debug statements here
20073 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
20075 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20076 if(!isWasmInitialized) {
20077 throw new Error("initializeWasm() must be awaited first!");
20079 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
20080 return nativeResponseValue;
20082 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
20084 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20085 if(!isWasmInitialized) {
20086 throw new Error("initializeWasm() must be awaited first!");
20088 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
20089 return nativeResponseValue;
20091 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
20093 export function COption_MonitorEventZ_some(o: bigint): bigint {
20094 if(!isWasmInitialized) {
20095 throw new Error("initializeWasm() must be awaited first!");
20097 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
20098 return nativeResponseValue;
20100 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
20102 export function COption_MonitorEventZ_none(): bigint {
20103 if(!isWasmInitialized) {
20104 throw new Error("initializeWasm() must be awaited first!");
20106 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
20107 return nativeResponseValue;
20109 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
20111 export function COption_MonitorEventZ_free(_res: bigint): void {
20112 if(!isWasmInitialized) {
20113 throw new Error("initializeWasm() must be awaited first!");
20115 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
20116 // debug statements here
20118 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
20120 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
20121 if(!isWasmInitialized) {
20122 throw new Error("initializeWasm() must be awaited first!");
20124 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
20125 return nativeResponseValue;
20127 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
20129 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
20130 if(!isWasmInitialized) {
20131 throw new Error("initializeWasm() must be awaited first!");
20133 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
20134 return nativeResponseValue;
20136 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
20138 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
20139 if(!isWasmInitialized) {
20140 throw new Error("initializeWasm() must be awaited first!");
20142 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
20143 return nativeResponseValue;
20145 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
20147 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
20148 if(!isWasmInitialized) {
20149 throw new Error("initializeWasm() must be awaited first!");
20151 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
20152 return nativeResponseValue;
20154 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
20156 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
20157 if(!isWasmInitialized) {
20158 throw new Error("initializeWasm() must be awaited first!");
20160 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
20161 return nativeResponseValue;
20163 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
20165 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
20166 if(!isWasmInitialized) {
20167 throw new Error("initializeWasm() must be awaited first!");
20169 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
20170 // debug statements here
20172 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
20174 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20175 if(!isWasmInitialized) {
20176 throw new Error("initializeWasm() must be awaited first!");
20178 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
20179 return nativeResponseValue;
20181 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
20183 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
20184 if(!isWasmInitialized) {
20185 throw new Error("initializeWasm() must be awaited first!");
20187 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
20188 return nativeResponseValue;
20190 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
20192 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
20193 if(!isWasmInitialized) {
20194 throw new Error("initializeWasm() must be awaited first!");
20196 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
20197 return nativeResponseValue;
20199 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20201 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
20202 if(!isWasmInitialized) {
20203 throw new Error("initializeWasm() must be awaited first!");
20205 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
20206 return nativeResponseValue;
20208 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
20210 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20211 if(!isWasmInitialized) {
20212 throw new Error("initializeWasm() must be awaited first!");
20214 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
20215 return nativeResponseValue;
20217 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
20219 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
20220 if(!isWasmInitialized) {
20221 throw new Error("initializeWasm() must be awaited first!");
20223 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
20224 // debug statements here
20226 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
20228 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20229 if(!isWasmInitialized) {
20230 throw new Error("initializeWasm() must be awaited first!");
20232 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
20233 return nativeResponseValue;
20235 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
20237 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20238 if(!isWasmInitialized) {
20239 throw new Error("initializeWasm() must be awaited first!");
20241 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
20242 return nativeResponseValue;
20244 // uint64_t C2Tuple_OutPointCVec_u8ZZ_clone_ptr(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR arg);
20246 export function C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg: bigint): bigint {
20247 if(!isWasmInitialized) {
20248 throw new Error("initializeWasm() must be awaited first!");
20250 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg);
20251 return nativeResponseValue;
20253 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_clone(const struct LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR orig);
20255 export function C2Tuple_OutPointCVec_u8ZZ_clone(orig: bigint): bigint {
20256 if(!isWasmInitialized) {
20257 throw new Error("initializeWasm() must be awaited first!");
20259 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone(orig);
20260 return nativeResponseValue;
20262 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
20264 export function C2Tuple_OutPointCVec_u8ZZ_new(a: bigint, b: number): bigint {
20265 if(!isWasmInitialized) {
20266 throw new Error("initializeWasm() must be awaited first!");
20268 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_new(a, b);
20269 return nativeResponseValue;
20271 // void C2Tuple_OutPointCVec_u8ZZ_free(struct LDKC2Tuple_OutPointCVec_u8ZZ _res);
20273 export function C2Tuple_OutPointCVec_u8ZZ_free(_res: bigint): void {
20274 if(!isWasmInitialized) {
20275 throw new Error("initializeWasm() must be awaited first!");
20277 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_free(_res);
20278 // debug statements here
20280 // uint64_t C2Tuple_u32CVec_u8ZZ_clone_ptr(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR arg);
20282 export function C2Tuple_u32CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
20283 if(!isWasmInitialized) {
20284 throw new Error("initializeWasm() must be awaited first!");
20286 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone_ptr(arg);
20287 return nativeResponseValue;
20289 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_clone(const struct LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR orig);
20291 export function C2Tuple_u32CVec_u8ZZ_clone(orig: bigint): bigint {
20292 if(!isWasmInitialized) {
20293 throw new Error("initializeWasm() must be awaited first!");
20295 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone(orig);
20296 return nativeResponseValue;
20298 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_new(uint32_t a, struct LDKCVec_u8Z b);
20300 export function C2Tuple_u32CVec_u8ZZ_new(a: number, b: number): bigint {
20301 if(!isWasmInitialized) {
20302 throw new Error("initializeWasm() must be awaited first!");
20304 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_new(a, b);
20305 return nativeResponseValue;
20307 // void C2Tuple_u32CVec_u8ZZ_free(struct LDKC2Tuple_u32CVec_u8ZZ _res);
20309 export function C2Tuple_u32CVec_u8ZZ_free(_res: bigint): void {
20310 if(!isWasmInitialized) {
20311 throw new Error("initializeWasm() must be awaited first!");
20313 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_free(_res);
20314 // debug statements here
20316 // void CVec_C2Tuple_u32CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u32CVec_u8ZZZ _res);
20318 export function CVec_C2Tuple_u32CVec_u8ZZZ_free(_res: number): void {
20319 if(!isWasmInitialized) {
20320 throw new Error("initializeWasm() must be awaited first!");
20322 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32CVec_u8ZZZ_free(_res);
20323 // debug statements here
20325 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR arg);
20327 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg: bigint): bigint {
20328 if(!isWasmInitialized) {
20329 throw new Error("initializeWasm() must be awaited first!");
20331 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg);
20332 return nativeResponseValue;
20334 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR orig);
20336 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig: bigint): bigint {
20337 if(!isWasmInitialized) {
20338 throw new Error("initializeWasm() must be awaited first!");
20340 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig);
20341 return nativeResponseValue;
20343 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32CVec_u8ZZZ b);
20345 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a: number, b: number): bigint {
20346 if(!isWasmInitialized) {
20347 throw new Error("initializeWasm() must be awaited first!");
20349 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a, b);
20350 return nativeResponseValue;
20352 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res);
20354 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res: bigint): void {
20355 if(!isWasmInitialized) {
20356 throw new Error("initializeWasm() must be awaited first!");
20358 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res);
20359 // debug statements here
20361 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ _res);
20363 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res: number): void {
20364 if(!isWasmInitialized) {
20365 throw new Error("initializeWasm() must be awaited first!");
20367 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res);
20368 // debug statements here
20370 // void CVec_CommitmentTransactionZ_free(struct LDKCVec_CommitmentTransactionZ _res);
20372 export function CVec_CommitmentTransactionZ_free(_res: number): void {
20373 if(!isWasmInitialized) {
20374 throw new Error("initializeWasm() must be awaited first!");
20376 const nativeResponseValue = wasm.TS_CVec_CommitmentTransactionZ_free(_res);
20377 // debug statements here
20379 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
20381 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
20382 if(!isWasmInitialized) {
20383 throw new Error("initializeWasm() must be awaited first!");
20385 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
20386 return nativeResponseValue;
20388 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
20390 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
20391 if(!isWasmInitialized) {
20392 throw new Error("initializeWasm() must be awaited first!");
20394 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
20395 return nativeResponseValue;
20397 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
20399 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
20400 if(!isWasmInitialized) {
20401 throw new Error("initializeWasm() must be awaited first!");
20403 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
20404 return nativeResponseValue;
20406 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
20408 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
20409 if(!isWasmInitialized) {
20410 throw new Error("initializeWasm() must be awaited first!");
20412 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
20413 // debug statements here
20415 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
20417 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
20418 if(!isWasmInitialized) {
20419 throw new Error("initializeWasm() must be awaited first!");
20421 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
20422 // debug statements here
20424 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
20426 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
20427 if(!isWasmInitialized) {
20428 throw new Error("initializeWasm() must be awaited first!");
20430 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
20431 return nativeResponseValue;
20433 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
20435 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
20436 if(!isWasmInitialized) {
20437 throw new Error("initializeWasm() must be awaited first!");
20439 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig);
20440 return nativeResponseValue;
20442 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
20444 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
20445 if(!isWasmInitialized) {
20446 throw new Error("initializeWasm() must be awaited first!");
20448 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a, b);
20449 return nativeResponseValue;
20451 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res);
20453 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
20454 if(!isWasmInitialized) {
20455 throw new Error("initializeWasm() must be awaited first!");
20457 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res);
20458 // debug statements here
20460 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ _res);
20462 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
20463 if(!isWasmInitialized) {
20464 throw new Error("initializeWasm() must be awaited first!");
20466 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res);
20467 // debug statements here
20469 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
20471 export function CVec_BalanceZ_free(_res: number): void {
20472 if(!isWasmInitialized) {
20473 throw new Error("initializeWasm() must be awaited first!");
20475 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
20476 // debug statements here
20478 // uint64_t C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR arg);
20480 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg: bigint): bigint {
20481 if(!isWasmInitialized) {
20482 throw new Error("initializeWasm() must be awaited first!");
20484 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg);
20485 return nativeResponseValue;
20487 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR orig);
20489 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig: bigint): bigint {
20490 if(!isWasmInitialized) {
20491 throw new Error("initializeWasm() must be awaited first!");
20493 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig);
20494 return nativeResponseValue;
20496 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
20498 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a: number, b: bigint): bigint {
20499 if(!isWasmInitialized) {
20500 throw new Error("initializeWasm() must be awaited first!");
20502 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a, b);
20503 return nativeResponseValue;
20505 // void C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res);
20507 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res: bigint): void {
20508 if(!isWasmInitialized) {
20509 throw new Error("initializeWasm() must be awaited first!");
20511 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res);
20512 // debug statements here
20514 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
20516 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
20517 if(!isWasmInitialized) {
20518 throw new Error("initializeWasm() must be awaited first!");
20520 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o);
20521 return nativeResponseValue;
20523 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
20525 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
20526 if(!isWasmInitialized) {
20527 throw new Error("initializeWasm() must be awaited first!");
20529 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e);
20530 return nativeResponseValue;
20532 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
20534 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
20535 if(!isWasmInitialized) {
20536 throw new Error("initializeWasm() must be awaited first!");
20538 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o);
20539 return nativeResponseValue;
20541 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ _res);
20543 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
20544 if(!isWasmInitialized) {
20545 throw new Error("initializeWasm() must be awaited first!");
20547 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res);
20548 // debug statements here
20550 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
20552 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20553 if(!isWasmInitialized) {
20554 throw new Error("initializeWasm() must be awaited first!");
20556 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg);
20557 return nativeResponseValue;
20559 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
20561 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
20562 if(!isWasmInitialized) {
20563 throw new Error("initializeWasm() must be awaited first!");
20565 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig);
20566 return nativeResponseValue;
20568 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
20570 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
20571 if(!isWasmInitialized) {
20572 throw new Error("initializeWasm() must be awaited first!");
20574 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
20575 return nativeResponseValue;
20577 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
20579 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
20580 if(!isWasmInitialized) {
20581 throw new Error("initializeWasm() must be awaited first!");
20583 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
20584 return nativeResponseValue;
20586 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
20588 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
20589 if(!isWasmInitialized) {
20590 throw new Error("initializeWasm() must be awaited first!");
20592 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
20593 return nativeResponseValue;
20595 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
20597 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
20598 if(!isWasmInitialized) {
20599 throw new Error("initializeWasm() must be awaited first!");
20601 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
20602 // debug statements here
20604 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
20606 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
20607 if(!isWasmInitialized) {
20608 throw new Error("initializeWasm() must be awaited first!");
20610 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
20611 // debug statements here
20613 // uint64_t C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR arg);
20615 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
20616 if(!isWasmInitialized) {
20617 throw new Error("initializeWasm() must be awaited first!");
20619 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(arg);
20620 return nativeResponseValue;
20622 // struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR orig);
20624 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(orig: bigint): bigint {
20625 if(!isWasmInitialized) {
20626 throw new Error("initializeWasm() must be awaited first!");
20628 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(orig);
20629 return nativeResponseValue;
20631 // struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ C2Tuple_PublicKeyCVec_SocketAddressZZ_new(struct LDKPublicKey a, struct LDKCVec_SocketAddressZ b);
20633 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_new(a: number, b: number): bigint {
20634 if(!isWasmInitialized) {
20635 throw new Error("initializeWasm() must be awaited first!");
20637 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_new(a, b);
20638 return nativeResponseValue;
20640 // void C2Tuple_PublicKeyCVec_SocketAddressZZ_free(struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ _res);
20642 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_free(_res: bigint): void {
20643 if(!isWasmInitialized) {
20644 throw new Error("initializeWasm() must be awaited first!");
20646 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_free(_res);
20647 // debug statements here
20649 // void CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ _res);
20651 export function CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(_res: number): void {
20652 if(!isWasmInitialized) {
20653 throw new Error("initializeWasm() must be awaited first!");
20655 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(_res);
20656 // debug statements here
20658 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_some(struct LDKOnionMessageContents o);
20660 export function COption_OnionMessageContentsZ_some(o: bigint): bigint {
20661 if(!isWasmInitialized) {
20662 throw new Error("initializeWasm() must be awaited first!");
20664 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_some(o);
20665 return nativeResponseValue;
20667 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_none(void);
20669 export function COption_OnionMessageContentsZ_none(): bigint {
20670 if(!isWasmInitialized) {
20671 throw new Error("initializeWasm() must be awaited first!");
20673 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_none();
20674 return nativeResponseValue;
20676 // void COption_OnionMessageContentsZ_free(struct LDKCOption_OnionMessageContentsZ _res);
20678 export function COption_OnionMessageContentsZ_free(_res: bigint): void {
20679 if(!isWasmInitialized) {
20680 throw new Error("initializeWasm() must be awaited first!");
20682 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_free(_res);
20683 // debug statements here
20685 // uint64_t COption_OnionMessageContentsZ_clone_ptr(LDKCOption_OnionMessageContentsZ *NONNULL_PTR arg);
20687 export function COption_OnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
20688 if(!isWasmInitialized) {
20689 throw new Error("initializeWasm() must be awaited first!");
20691 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone_ptr(arg);
20692 return nativeResponseValue;
20694 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_clone(const struct LDKCOption_OnionMessageContentsZ *NONNULL_PTR orig);
20696 export function COption_OnionMessageContentsZ_clone(orig: bigint): bigint {
20697 if(!isWasmInitialized) {
20698 throw new Error("initializeWasm() must be awaited first!");
20700 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone(orig);
20701 return nativeResponseValue;
20703 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_OnionMessageContentsZ o);
20705 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
20706 if(!isWasmInitialized) {
20707 throw new Error("initializeWasm() must be awaited first!");
20709 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o);
20710 return nativeResponseValue;
20712 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
20714 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
20715 if(!isWasmInitialized) {
20716 throw new Error("initializeWasm() must be awaited first!");
20718 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e);
20719 return nativeResponseValue;
20721 // bool CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
20723 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
20724 if(!isWasmInitialized) {
20725 throw new Error("initializeWasm() must be awaited first!");
20727 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o);
20728 return nativeResponseValue;
20730 // void CResult_COption_OnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ _res);
20732 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
20733 if(!isWasmInitialized) {
20734 throw new Error("initializeWasm() must be awaited first!");
20736 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res);
20737 // debug statements here
20739 // uint64_t CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
20741 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20742 if(!isWasmInitialized) {
20743 throw new Error("initializeWasm() must be awaited first!");
20745 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
20746 return nativeResponseValue;
20748 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
20750 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
20751 if(!isWasmInitialized) {
20752 throw new Error("initializeWasm() must be awaited first!");
20754 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig);
20755 return nativeResponseValue;
20757 // uint64_t C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR arg);
20759 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
20760 if(!isWasmInitialized) {
20761 throw new Error("initializeWasm() must be awaited first!");
20763 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg);
20764 return nativeResponseValue;
20766 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR orig);
20768 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig: bigint): bigint {
20769 if(!isWasmInitialized) {
20770 throw new Error("initializeWasm() must be awaited first!");
20772 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig);
20773 return nativeResponseValue;
20775 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(struct LDKOnionMessageContents a, struct LDKDestination b, struct LDKBlindedPath c);
20777 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
20778 if(!isWasmInitialized) {
20779 throw new Error("initializeWasm() must be awaited first!");
20781 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a, b, c);
20782 return nativeResponseValue;
20784 // void C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ _res);
20786 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res: bigint): void {
20787 if(!isWasmInitialized) {
20788 throw new Error("initializeWasm() must be awaited first!");
20790 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res);
20791 // debug statements here
20793 // void CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ _res);
20795 export function CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res: number): void {
20796 if(!isWasmInitialized) {
20797 throw new Error("initializeWasm() must be awaited first!");
20799 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res);
20800 // debug statements here
20802 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
20804 export function COption_TypeZ_some(o: bigint): bigint {
20805 if(!isWasmInitialized) {
20806 throw new Error("initializeWasm() must be awaited first!");
20808 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
20809 return nativeResponseValue;
20811 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
20813 export function COption_TypeZ_none(): bigint {
20814 if(!isWasmInitialized) {
20815 throw new Error("initializeWasm() must be awaited first!");
20817 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
20818 return nativeResponseValue;
20820 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
20822 export function COption_TypeZ_free(_res: bigint): void {
20823 if(!isWasmInitialized) {
20824 throw new Error("initializeWasm() must be awaited first!");
20826 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
20827 // debug statements here
20829 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
20831 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
20832 if(!isWasmInitialized) {
20833 throw new Error("initializeWasm() must be awaited first!");
20835 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
20836 return nativeResponseValue;
20838 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
20840 export function COption_TypeZ_clone(orig: bigint): bigint {
20841 if(!isWasmInitialized) {
20842 throw new Error("initializeWasm() must be awaited first!");
20844 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
20845 return nativeResponseValue;
20847 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
20849 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
20850 if(!isWasmInitialized) {
20851 throw new Error("initializeWasm() must be awaited first!");
20853 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
20854 return nativeResponseValue;
20856 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
20858 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
20859 if(!isWasmInitialized) {
20860 throw new Error("initializeWasm() must be awaited first!");
20862 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
20863 return nativeResponseValue;
20865 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
20867 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
20868 if(!isWasmInitialized) {
20869 throw new Error("initializeWasm() must be awaited first!");
20871 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
20872 return nativeResponseValue;
20874 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
20876 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
20877 if(!isWasmInitialized) {
20878 throw new Error("initializeWasm() must be awaited first!");
20880 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
20881 // debug statements here
20883 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
20885 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20886 if(!isWasmInitialized) {
20887 throw new Error("initializeWasm() must be awaited first!");
20889 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
20890 return nativeResponseValue;
20892 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
20894 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
20895 if(!isWasmInitialized) {
20896 throw new Error("initializeWasm() must be awaited first!");
20898 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
20899 return nativeResponseValue;
20901 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_some(struct LDKSocketAddress o);
20903 export function COption_SocketAddressZ_some(o: bigint): bigint {
20904 if(!isWasmInitialized) {
20905 throw new Error("initializeWasm() must be awaited first!");
20907 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_some(o);
20908 return nativeResponseValue;
20910 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_none(void);
20912 export function COption_SocketAddressZ_none(): bigint {
20913 if(!isWasmInitialized) {
20914 throw new Error("initializeWasm() must be awaited first!");
20916 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_none();
20917 return nativeResponseValue;
20919 // void COption_SocketAddressZ_free(struct LDKCOption_SocketAddressZ _res);
20921 export function COption_SocketAddressZ_free(_res: bigint): void {
20922 if(!isWasmInitialized) {
20923 throw new Error("initializeWasm() must be awaited first!");
20925 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_free(_res);
20926 // debug statements here
20928 // uint64_t COption_SocketAddressZ_clone_ptr(LDKCOption_SocketAddressZ *NONNULL_PTR arg);
20930 export function COption_SocketAddressZ_clone_ptr(arg: bigint): bigint {
20931 if(!isWasmInitialized) {
20932 throw new Error("initializeWasm() must be awaited first!");
20934 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone_ptr(arg);
20935 return nativeResponseValue;
20937 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_clone(const struct LDKCOption_SocketAddressZ *NONNULL_PTR orig);
20939 export function COption_SocketAddressZ_clone(orig: bigint): bigint {
20940 if(!isWasmInitialized) {
20941 throw new Error("initializeWasm() must be awaited first!");
20943 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone(orig);
20944 return nativeResponseValue;
20946 // void CVec_PeerDetailsZ_free(struct LDKCVec_PeerDetailsZ _res);
20948 export function CVec_PeerDetailsZ_free(_res: number): void {
20949 if(!isWasmInitialized) {
20950 throw new Error("initializeWasm() must be awaited first!");
20952 const nativeResponseValue = wasm.TS_CVec_PeerDetailsZ_free(_res);
20953 // debug statements here
20955 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
20957 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
20958 if(!isWasmInitialized) {
20959 throw new Error("initializeWasm() must be awaited first!");
20961 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
20962 return nativeResponseValue;
20964 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
20966 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
20967 if(!isWasmInitialized) {
20968 throw new Error("initializeWasm() must be awaited first!");
20970 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
20971 return nativeResponseValue;
20973 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
20975 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
20976 if(!isWasmInitialized) {
20977 throw new Error("initializeWasm() must be awaited first!");
20979 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
20980 return nativeResponseValue;
20982 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
20984 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
20985 if(!isWasmInitialized) {
20986 throw new Error("initializeWasm() must be awaited first!");
20988 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
20989 // debug statements here
20991 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
20993 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
20994 if(!isWasmInitialized) {
20995 throw new Error("initializeWasm() must be awaited first!");
20997 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
20998 return nativeResponseValue;
21000 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
21002 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
21003 if(!isWasmInitialized) {
21004 throw new Error("initializeWasm() must be awaited first!");
21006 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
21007 return nativeResponseValue;
21009 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
21011 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
21012 if(!isWasmInitialized) {
21013 throw new Error("initializeWasm() must be awaited first!");
21015 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
21016 return nativeResponseValue;
21018 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
21020 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
21021 if(!isWasmInitialized) {
21022 throw new Error("initializeWasm() must be awaited first!");
21024 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
21025 return nativeResponseValue;
21027 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
21029 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
21030 if(!isWasmInitialized) {
21031 throw new Error("initializeWasm() must be awaited first!");
21033 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
21034 return nativeResponseValue;
21036 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
21038 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
21039 if(!isWasmInitialized) {
21040 throw new Error("initializeWasm() must be awaited first!");
21042 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
21043 // debug statements here
21045 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
21047 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
21048 if(!isWasmInitialized) {
21049 throw new Error("initializeWasm() must be awaited first!");
21051 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
21052 return nativeResponseValue;
21054 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
21056 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
21057 if(!isWasmInitialized) {
21058 throw new Error("initializeWasm() must be awaited first!");
21060 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
21061 return nativeResponseValue;
21063 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
21065 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
21066 if(!isWasmInitialized) {
21067 throw new Error("initializeWasm() must be awaited first!");
21069 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
21070 return nativeResponseValue;
21072 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
21074 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
21075 if(!isWasmInitialized) {
21076 throw new Error("initializeWasm() must be awaited first!");
21078 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
21079 return nativeResponseValue;
21081 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
21083 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
21084 if(!isWasmInitialized) {
21085 throw new Error("initializeWasm() must be awaited first!");
21087 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
21088 return nativeResponseValue;
21090 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
21092 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
21093 if(!isWasmInitialized) {
21094 throw new Error("initializeWasm() must be awaited first!");
21096 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
21097 // debug statements here
21099 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
21101 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
21102 if(!isWasmInitialized) {
21103 throw new Error("initializeWasm() must be awaited first!");
21105 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
21106 return nativeResponseValue;
21108 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
21110 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
21111 if(!isWasmInitialized) {
21112 throw new Error("initializeWasm() must be awaited first!");
21114 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
21115 return nativeResponseValue;
21117 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
21119 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
21120 if(!isWasmInitialized) {
21121 throw new Error("initializeWasm() must be awaited first!");
21123 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
21124 return nativeResponseValue;
21126 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
21128 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
21129 if(!isWasmInitialized) {
21130 throw new Error("initializeWasm() must be awaited first!");
21132 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
21133 return nativeResponseValue;
21135 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
21137 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
21138 if(!isWasmInitialized) {
21139 throw new Error("initializeWasm() must be awaited first!");
21141 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
21142 return nativeResponseValue;
21144 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
21146 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
21147 if(!isWasmInitialized) {
21148 throw new Error("initializeWasm() must be awaited first!");
21150 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
21151 // debug statements here
21153 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_ok(struct LDKCVec_u8Z o);
21155 export function CResult_CVec_u8ZIOErrorZ_ok(o: number): bigint {
21156 if(!isWasmInitialized) {
21157 throw new Error("initializeWasm() must be awaited first!");
21159 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_ok(o);
21160 return nativeResponseValue;
21162 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_err(enum LDKIOError e);
21164 export function CResult_CVec_u8ZIOErrorZ_err(e: IOError): bigint {
21165 if(!isWasmInitialized) {
21166 throw new Error("initializeWasm() must be awaited first!");
21168 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_err(e);
21169 return nativeResponseValue;
21171 // bool CResult_CVec_u8ZIOErrorZ_is_ok(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR o);
21173 export function CResult_CVec_u8ZIOErrorZ_is_ok(o: bigint): boolean {
21174 if(!isWasmInitialized) {
21175 throw new Error("initializeWasm() must be awaited first!");
21177 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_is_ok(o);
21178 return nativeResponseValue;
21180 // void CResult_CVec_u8ZIOErrorZ_free(struct LDKCResult_CVec_u8ZIOErrorZ _res);
21182 export function CResult_CVec_u8ZIOErrorZ_free(_res: bigint): void {
21183 if(!isWasmInitialized) {
21184 throw new Error("initializeWasm() must be awaited first!");
21186 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_free(_res);
21187 // debug statements here
21189 // uint64_t CResult_CVec_u8ZIOErrorZ_clone_ptr(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR arg);
21191 export function CResult_CVec_u8ZIOErrorZ_clone_ptr(arg: bigint): bigint {
21192 if(!isWasmInitialized) {
21193 throw new Error("initializeWasm() must be awaited first!");
21195 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone_ptr(arg);
21196 return nativeResponseValue;
21198 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_clone(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR orig);
21200 export function CResult_CVec_u8ZIOErrorZ_clone(orig: bigint): bigint {
21201 if(!isWasmInitialized) {
21202 throw new Error("initializeWasm() must be awaited first!");
21204 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone(orig);
21205 return nativeResponseValue;
21207 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_ok(void);
21209 export function CResult_NoneIOErrorZ_ok(): bigint {
21210 if(!isWasmInitialized) {
21211 throw new Error("initializeWasm() must be awaited first!");
21213 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_ok();
21214 return nativeResponseValue;
21216 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_err(enum LDKIOError e);
21218 export function CResult_NoneIOErrorZ_err(e: IOError): bigint {
21219 if(!isWasmInitialized) {
21220 throw new Error("initializeWasm() must be awaited first!");
21222 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_err(e);
21223 return nativeResponseValue;
21225 // bool CResult_NoneIOErrorZ_is_ok(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR o);
21227 export function CResult_NoneIOErrorZ_is_ok(o: bigint): boolean {
21228 if(!isWasmInitialized) {
21229 throw new Error("initializeWasm() must be awaited first!");
21231 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_is_ok(o);
21232 return nativeResponseValue;
21234 // void CResult_NoneIOErrorZ_free(struct LDKCResult_NoneIOErrorZ _res);
21236 export function CResult_NoneIOErrorZ_free(_res: bigint): void {
21237 if(!isWasmInitialized) {
21238 throw new Error("initializeWasm() must be awaited first!");
21240 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_free(_res);
21241 // debug statements here
21243 // uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg);
21245 export function CResult_NoneIOErrorZ_clone_ptr(arg: bigint): bigint {
21246 if(!isWasmInitialized) {
21247 throw new Error("initializeWasm() must be awaited first!");
21249 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone_ptr(arg);
21250 return nativeResponseValue;
21252 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_clone(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR orig);
21254 export function CResult_NoneIOErrorZ_clone(orig: bigint): bigint {
21255 if(!isWasmInitialized) {
21256 throw new Error("initializeWasm() must be awaited first!");
21258 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone(orig);
21259 return nativeResponseValue;
21261 // void CVec_StrZ_free(struct LDKCVec_StrZ _res);
21263 export function CVec_StrZ_free(_res: number): void {
21264 if(!isWasmInitialized) {
21265 throw new Error("initializeWasm() must be awaited first!");
21267 const nativeResponseValue = wasm.TS_CVec_StrZ_free(_res);
21268 // debug statements here
21270 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_ok(struct LDKCVec_StrZ o);
21272 export function CResult_CVec_StrZIOErrorZ_ok(o: number): bigint {
21273 if(!isWasmInitialized) {
21274 throw new Error("initializeWasm() must be awaited first!");
21276 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_ok(o);
21277 return nativeResponseValue;
21279 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_err(enum LDKIOError e);
21281 export function CResult_CVec_StrZIOErrorZ_err(e: IOError): bigint {
21282 if(!isWasmInitialized) {
21283 throw new Error("initializeWasm() must be awaited first!");
21285 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_err(e);
21286 return nativeResponseValue;
21288 // bool CResult_CVec_StrZIOErrorZ_is_ok(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR o);
21290 export function CResult_CVec_StrZIOErrorZ_is_ok(o: bigint): boolean {
21291 if(!isWasmInitialized) {
21292 throw new Error("initializeWasm() must be awaited first!");
21294 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_is_ok(o);
21295 return nativeResponseValue;
21297 // void CResult_CVec_StrZIOErrorZ_free(struct LDKCResult_CVec_StrZIOErrorZ _res);
21299 export function CResult_CVec_StrZIOErrorZ_free(_res: bigint): void {
21300 if(!isWasmInitialized) {
21301 throw new Error("initializeWasm() must be awaited first!");
21303 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_free(_res);
21304 // debug statements here
21306 // uint64_t CResult_CVec_StrZIOErrorZ_clone_ptr(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR arg);
21308 export function CResult_CVec_StrZIOErrorZ_clone_ptr(arg: bigint): bigint {
21309 if(!isWasmInitialized) {
21310 throw new Error("initializeWasm() must be awaited first!");
21312 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone_ptr(arg);
21313 return nativeResponseValue;
21315 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_clone(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR orig);
21317 export function CResult_CVec_StrZIOErrorZ_clone(orig: bigint): bigint {
21318 if(!isWasmInitialized) {
21319 throw new Error("initializeWasm() must be awaited first!");
21321 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone(orig);
21322 return nativeResponseValue;
21324 // void CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ _res);
21326 export function CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res: number): void {
21327 if(!isWasmInitialized) {
21328 throw new Error("initializeWasm() must be awaited first!");
21330 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res);
21331 // debug statements here
21333 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ o);
21335 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o: number): bigint {
21336 if(!isWasmInitialized) {
21337 throw new Error("initializeWasm() must be awaited first!");
21339 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o);
21340 return nativeResponseValue;
21342 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(enum LDKIOError e);
21344 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e: IOError): bigint {
21345 if(!isWasmInitialized) {
21346 throw new Error("initializeWasm() must be awaited first!");
21348 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e);
21349 return nativeResponseValue;
21351 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR o);
21353 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o: bigint): boolean {
21354 if(!isWasmInitialized) {
21355 throw new Error("initializeWasm() must be awaited first!");
21357 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o);
21358 return nativeResponseValue;
21360 // void CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ _res);
21362 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res: bigint): void {
21363 if(!isWasmInitialized) {
21364 throw new Error("initializeWasm() must be awaited first!");
21366 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res);
21367 // debug statements here
21369 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR arg);
21371 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg: bigint): bigint {
21372 if(!isWasmInitialized) {
21373 throw new Error("initializeWasm() must be awaited first!");
21375 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg);
21376 return nativeResponseValue;
21378 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR orig);
21380 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig: bigint): bigint {
21381 if(!isWasmInitialized) {
21382 throw new Error("initializeWasm() must be awaited first!");
21384 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig);
21385 return nativeResponseValue;
21387 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
21389 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o: bigint): bigint {
21390 if(!isWasmInitialized) {
21391 throw new Error("initializeWasm() must be awaited first!");
21393 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o);
21394 return nativeResponseValue;
21396 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(enum LDKIOError e);
21398 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e: IOError): bigint {
21399 if(!isWasmInitialized) {
21400 throw new Error("initializeWasm() must be awaited first!");
21402 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e);
21403 return nativeResponseValue;
21405 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR o);
21407 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o: bigint): boolean {
21408 if(!isWasmInitialized) {
21409 throw new Error("initializeWasm() must be awaited first!");
21411 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o);
21412 return nativeResponseValue;
21414 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ _res);
21416 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res: bigint): void {
21417 if(!isWasmInitialized) {
21418 throw new Error("initializeWasm() must be awaited first!");
21420 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res);
21421 // debug statements here
21423 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR arg);
21425 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg: bigint): bigint {
21426 if(!isWasmInitialized) {
21427 throw new Error("initializeWasm() must be awaited first!");
21429 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg);
21430 return nativeResponseValue;
21432 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR orig);
21434 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig: bigint): bigint {
21435 if(!isWasmInitialized) {
21436 throw new Error("initializeWasm() must be awaited first!");
21438 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig);
21439 return nativeResponseValue;
21441 // struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_ok(struct LDKUnsignedInvoiceRequest o);
21443 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_ok(o: bigint): bigint {
21444 if(!isWasmInitialized) {
21445 throw new Error("initializeWasm() must be awaited first!");
21447 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_ok(o);
21448 return nativeResponseValue;
21450 // struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
21452 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
21453 if(!isWasmInitialized) {
21454 throw new Error("initializeWasm() must be awaited first!");
21456 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_err(e);
21457 return nativeResponseValue;
21459 // bool CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_is_ok(const struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR o);
21461 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
21462 if(!isWasmInitialized) {
21463 throw new Error("initializeWasm() must be awaited first!");
21465 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_is_ok(o);
21466 return nativeResponseValue;
21468 // void CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ _res);
21470 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(_res: bigint): void {
21471 if(!isWasmInitialized) {
21472 throw new Error("initializeWasm() must be awaited first!");
21474 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(_res);
21475 // debug statements here
21477 // uint64_t CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone_ptr(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR arg);
21479 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
21480 if(!isWasmInitialized) {
21481 throw new Error("initializeWasm() must be awaited first!");
21483 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone_ptr(arg);
21484 return nativeResponseValue;
21486 // struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone(const struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR orig);
21488 export function CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone(orig: bigint): bigint {
21489 if(!isWasmInitialized) {
21490 throw new Error("initializeWasm() must be awaited first!");
21492 const nativeResponseValue = wasm.TS_CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_clone(orig);
21493 return nativeResponseValue;
21495 // struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ CResult_InvoiceRequestBolt12SemanticErrorZ_ok(struct LDKInvoiceRequest o);
21497 export function CResult_InvoiceRequestBolt12SemanticErrorZ_ok(o: bigint): bigint {
21498 if(!isWasmInitialized) {
21499 throw new Error("initializeWasm() must be awaited first!");
21501 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_ok(o);
21502 return nativeResponseValue;
21504 // struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ CResult_InvoiceRequestBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
21506 export function CResult_InvoiceRequestBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
21507 if(!isWasmInitialized) {
21508 throw new Error("initializeWasm() must be awaited first!");
21510 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_err(e);
21511 return nativeResponseValue;
21513 // bool CResult_InvoiceRequestBolt12SemanticErrorZ_is_ok(const struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR o);
21515 export function CResult_InvoiceRequestBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
21516 if(!isWasmInitialized) {
21517 throw new Error("initializeWasm() must be awaited first!");
21519 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_is_ok(o);
21520 return nativeResponseValue;
21522 // void CResult_InvoiceRequestBolt12SemanticErrorZ_free(struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ _res);
21524 export function CResult_InvoiceRequestBolt12SemanticErrorZ_free(_res: bigint): void {
21525 if(!isWasmInitialized) {
21526 throw new Error("initializeWasm() must be awaited first!");
21528 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_free(_res);
21529 // debug statements here
21531 // uint64_t CResult_InvoiceRequestBolt12SemanticErrorZ_clone_ptr(LDKCResult_InvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR arg);
21533 export function CResult_InvoiceRequestBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
21534 if(!isWasmInitialized) {
21535 throw new Error("initializeWasm() must be awaited first!");
21537 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_clone_ptr(arg);
21538 return nativeResponseValue;
21540 // struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ CResult_InvoiceRequestBolt12SemanticErrorZ_clone(const struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ *NONNULL_PTR orig);
21542 export function CResult_InvoiceRequestBolt12SemanticErrorZ_clone(orig: bigint): bigint {
21543 if(!isWasmInitialized) {
21544 throw new Error("initializeWasm() must be awaited first!");
21546 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestBolt12SemanticErrorZ_clone(orig);
21547 return nativeResponseValue;
21549 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_some(struct LDKSecretKey o);
21551 export function COption_SecretKeyZ_some(o: number): bigint {
21552 if(!isWasmInitialized) {
21553 throw new Error("initializeWasm() must be awaited first!");
21555 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_some(o);
21556 return nativeResponseValue;
21558 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_none(void);
21560 export function COption_SecretKeyZ_none(): bigint {
21561 if(!isWasmInitialized) {
21562 throw new Error("initializeWasm() must be awaited first!");
21564 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_none();
21565 return nativeResponseValue;
21567 // void COption_SecretKeyZ_free(struct LDKCOption_SecretKeyZ _res);
21569 export function COption_SecretKeyZ_free(_res: bigint): void {
21570 if(!isWasmInitialized) {
21571 throw new Error("initializeWasm() must be awaited first!");
21573 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_free(_res);
21574 // debug statements here
21576 // uint64_t COption_SecretKeyZ_clone_ptr(LDKCOption_SecretKeyZ *NONNULL_PTR arg);
21578 export function COption_SecretKeyZ_clone_ptr(arg: bigint): bigint {
21579 if(!isWasmInitialized) {
21580 throw new Error("initializeWasm() must be awaited first!");
21582 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone_ptr(arg);
21583 return nativeResponseValue;
21585 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_clone(const struct LDKCOption_SecretKeyZ *NONNULL_PTR orig);
21587 export function COption_SecretKeyZ_clone(orig: bigint): bigint {
21588 if(!isWasmInitialized) {
21589 throw new Error("initializeWasm() must be awaited first!");
21591 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone(orig);
21592 return nativeResponseValue;
21594 // struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_ok(struct LDKInvoiceWithExplicitSigningPubkeyBuilder o);
21596 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
21597 if(!isWasmInitialized) {
21598 throw new Error("initializeWasm() must be awaited first!");
21600 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_ok(o);
21601 return nativeResponseValue;
21603 // struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
21605 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
21606 if(!isWasmInitialized) {
21607 throw new Error("initializeWasm() must be awaited first!");
21609 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_err(e);
21610 return nativeResponseValue;
21612 // bool CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
21614 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
21615 if(!isWasmInitialized) {
21616 throw new Error("initializeWasm() must be awaited first!");
21618 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(o);
21619 return nativeResponseValue;
21621 // void CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ _res);
21623 export function CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
21624 if(!isWasmInitialized) {
21625 throw new Error("initializeWasm() must be awaited first!");
21627 const nativeResponseValue = wasm.TS_CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(_res);
21628 // debug statements here
21630 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_ok(struct LDKVerifiedInvoiceRequest o);
21632 export function CResult_VerifiedInvoiceRequestNoneZ_ok(o: bigint): bigint {
21633 if(!isWasmInitialized) {
21634 throw new Error("initializeWasm() must be awaited first!");
21636 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_ok(o);
21637 return nativeResponseValue;
21639 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_err(void);
21641 export function CResult_VerifiedInvoiceRequestNoneZ_err(): bigint {
21642 if(!isWasmInitialized) {
21643 throw new Error("initializeWasm() must be awaited first!");
21645 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_err();
21646 return nativeResponseValue;
21648 // bool CResult_VerifiedInvoiceRequestNoneZ_is_ok(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR o);
21650 export function CResult_VerifiedInvoiceRequestNoneZ_is_ok(o: bigint): boolean {
21651 if(!isWasmInitialized) {
21652 throw new Error("initializeWasm() must be awaited first!");
21654 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok(o);
21655 return nativeResponseValue;
21657 // void CResult_VerifiedInvoiceRequestNoneZ_free(struct LDKCResult_VerifiedInvoiceRequestNoneZ _res);
21659 export function CResult_VerifiedInvoiceRequestNoneZ_free(_res: bigint): void {
21660 if(!isWasmInitialized) {
21661 throw new Error("initializeWasm() must be awaited first!");
21663 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_free(_res);
21664 // debug statements here
21666 // uint64_t CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR arg);
21668 export function CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg: bigint): bigint {
21669 if(!isWasmInitialized) {
21670 throw new Error("initializeWasm() must be awaited first!");
21672 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg);
21673 return nativeResponseValue;
21675 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_clone(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR orig);
21677 export function CResult_VerifiedInvoiceRequestNoneZ_clone(orig: bigint): bigint {
21678 if(!isWasmInitialized) {
21679 throw new Error("initializeWasm() must be awaited first!");
21681 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone(orig);
21682 return nativeResponseValue;
21684 // struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_ok(struct LDKInvoiceWithDerivedSigningPubkeyBuilder o);
21686 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_ok(o: bigint): bigint {
21687 if(!isWasmInitialized) {
21688 throw new Error("initializeWasm() must be awaited first!");
21690 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_ok(o);
21691 return nativeResponseValue;
21693 // struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
21695 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
21696 if(!isWasmInitialized) {
21697 throw new Error("initializeWasm() must be awaited first!");
21699 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_err(e);
21700 return nativeResponseValue;
21702 // bool CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(const struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ *NONNULL_PTR o);
21704 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
21705 if(!isWasmInitialized) {
21706 throw new Error("initializeWasm() must be awaited first!");
21708 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_is_ok(o);
21709 return nativeResponseValue;
21711 // void CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ _res);
21713 export function CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(_res: bigint): void {
21714 if(!isWasmInitialized) {
21715 throw new Error("initializeWasm() must be awaited first!");
21717 const nativeResponseValue = wasm.TS_CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(_res);
21718 // debug statements here
21720 // struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ CResult_InvoiceRequestFieldsDecodeErrorZ_ok(struct LDKInvoiceRequestFields o);
21722 export function CResult_InvoiceRequestFieldsDecodeErrorZ_ok(o: bigint): bigint {
21723 if(!isWasmInitialized) {
21724 throw new Error("initializeWasm() must be awaited first!");
21726 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_ok(o);
21727 return nativeResponseValue;
21729 // struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ CResult_InvoiceRequestFieldsDecodeErrorZ_err(struct LDKDecodeError e);
21731 export function CResult_InvoiceRequestFieldsDecodeErrorZ_err(e: bigint): bigint {
21732 if(!isWasmInitialized) {
21733 throw new Error("initializeWasm() must be awaited first!");
21735 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_err(e);
21736 return nativeResponseValue;
21738 // bool CResult_InvoiceRequestFieldsDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ *NONNULL_PTR o);
21740 export function CResult_InvoiceRequestFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
21741 if(!isWasmInitialized) {
21742 throw new Error("initializeWasm() must be awaited first!");
21744 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_is_ok(o);
21745 return nativeResponseValue;
21747 // void CResult_InvoiceRequestFieldsDecodeErrorZ_free(struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ _res);
21749 export function CResult_InvoiceRequestFieldsDecodeErrorZ_free(_res: bigint): void {
21750 if(!isWasmInitialized) {
21751 throw new Error("initializeWasm() must be awaited first!");
21753 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_free(_res);
21754 // debug statements here
21756 // uint64_t CResult_InvoiceRequestFieldsDecodeErrorZ_clone_ptr(LDKCResult_InvoiceRequestFieldsDecodeErrorZ *NONNULL_PTR arg);
21758 export function CResult_InvoiceRequestFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21759 if(!isWasmInitialized) {
21760 throw new Error("initializeWasm() must be awaited first!");
21762 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_clone_ptr(arg);
21763 return nativeResponseValue;
21765 // struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ CResult_InvoiceRequestFieldsDecodeErrorZ_clone(const struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ *NONNULL_PTR orig);
21767 export function CResult_InvoiceRequestFieldsDecodeErrorZ_clone(orig: bigint): bigint {
21768 if(!isWasmInitialized) {
21769 throw new Error("initializeWasm() must be awaited first!");
21771 const nativeResponseValue = wasm.TS_CResult_InvoiceRequestFieldsDecodeErrorZ_clone(orig);
21772 return nativeResponseValue;
21774 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
21776 export function COption_NoneZ_some(): COption_NoneZ {
21777 if(!isWasmInitialized) {
21778 throw new Error("initializeWasm() must be awaited first!");
21780 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
21781 return nativeResponseValue;
21783 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
21785 export function COption_NoneZ_none(): COption_NoneZ {
21786 if(!isWasmInitialized) {
21787 throw new Error("initializeWasm() must be awaited first!");
21789 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
21790 return nativeResponseValue;
21792 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
21794 export function COption_NoneZ_free(_res: COption_NoneZ): void {
21795 if(!isWasmInitialized) {
21796 throw new Error("initializeWasm() must be awaited first!");
21798 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
21799 // debug statements here
21801 // void CVec_WitnessZ_free(struct LDKCVec_WitnessZ _res);
21803 export function CVec_WitnessZ_free(_res: number): void {
21804 if(!isWasmInitialized) {
21805 throw new Error("initializeWasm() must be awaited first!");
21807 const nativeResponseValue = wasm.TS_CVec_WitnessZ_free(_res);
21808 // debug statements here
21810 // struct LDKCOption_ECDSASignatureZ COption_ECDSASignatureZ_some(struct LDKECDSASignature o);
21812 export function COption_ECDSASignatureZ_some(o: number): bigint {
21813 if(!isWasmInitialized) {
21814 throw new Error("initializeWasm() must be awaited first!");
21816 const nativeResponseValue = wasm.TS_COption_ECDSASignatureZ_some(o);
21817 return nativeResponseValue;
21819 // struct LDKCOption_ECDSASignatureZ COption_ECDSASignatureZ_none(void);
21821 export function COption_ECDSASignatureZ_none(): bigint {
21822 if(!isWasmInitialized) {
21823 throw new Error("initializeWasm() must be awaited first!");
21825 const nativeResponseValue = wasm.TS_COption_ECDSASignatureZ_none();
21826 return nativeResponseValue;
21828 // void COption_ECDSASignatureZ_free(struct LDKCOption_ECDSASignatureZ _res);
21830 export function COption_ECDSASignatureZ_free(_res: bigint): void {
21831 if(!isWasmInitialized) {
21832 throw new Error("initializeWasm() must be awaited first!");
21834 const nativeResponseValue = wasm.TS_COption_ECDSASignatureZ_free(_res);
21835 // debug statements here
21837 // uint64_t COption_ECDSASignatureZ_clone_ptr(LDKCOption_ECDSASignatureZ *NONNULL_PTR arg);
21839 export function COption_ECDSASignatureZ_clone_ptr(arg: bigint): bigint {
21840 if(!isWasmInitialized) {
21841 throw new Error("initializeWasm() must be awaited first!");
21843 const nativeResponseValue = wasm.TS_COption_ECDSASignatureZ_clone_ptr(arg);
21844 return nativeResponseValue;
21846 // struct LDKCOption_ECDSASignatureZ COption_ECDSASignatureZ_clone(const struct LDKCOption_ECDSASignatureZ *NONNULL_PTR orig);
21848 export function COption_ECDSASignatureZ_clone(orig: bigint): bigint {
21849 if(!isWasmInitialized) {
21850 throw new Error("initializeWasm() must be awaited first!");
21852 const nativeResponseValue = wasm.TS_COption_ECDSASignatureZ_clone(orig);
21853 return nativeResponseValue;
21855 // struct LDKCOption_i64Z COption_i64Z_some(int64_t o);
21857 export function COption_i64Z_some(o: bigint): bigint {
21858 if(!isWasmInitialized) {
21859 throw new Error("initializeWasm() must be awaited first!");
21861 const nativeResponseValue = wasm.TS_COption_i64Z_some(o);
21862 return nativeResponseValue;
21864 // struct LDKCOption_i64Z COption_i64Z_none(void);
21866 export function COption_i64Z_none(): bigint {
21867 if(!isWasmInitialized) {
21868 throw new Error("initializeWasm() must be awaited first!");
21870 const nativeResponseValue = wasm.TS_COption_i64Z_none();
21871 return nativeResponseValue;
21873 // void COption_i64Z_free(struct LDKCOption_i64Z _res);
21875 export function COption_i64Z_free(_res: bigint): void {
21876 if(!isWasmInitialized) {
21877 throw new Error("initializeWasm() must be awaited first!");
21879 const nativeResponseValue = wasm.TS_COption_i64Z_free(_res);
21880 // debug statements here
21882 // uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg);
21884 export function COption_i64Z_clone_ptr(arg: bigint): bigint {
21885 if(!isWasmInitialized) {
21886 throw new Error("initializeWasm() must be awaited first!");
21888 const nativeResponseValue = wasm.TS_COption_i64Z_clone_ptr(arg);
21889 return nativeResponseValue;
21891 // struct LDKCOption_i64Z COption_i64Z_clone(const struct LDKCOption_i64Z *NONNULL_PTR orig);
21893 export function COption_i64Z_clone(orig: bigint): bigint {
21894 if(!isWasmInitialized) {
21895 throw new Error("initializeWasm() must be awaited first!");
21897 const nativeResponseValue = wasm.TS_COption_i64Z_clone(orig);
21898 return nativeResponseValue;
21900 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_ok(struct LDKSocketAddress o);
21902 export function CResult_SocketAddressDecodeErrorZ_ok(o: bigint): bigint {
21903 if(!isWasmInitialized) {
21904 throw new Error("initializeWasm() must be awaited first!");
21906 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_ok(o);
21907 return nativeResponseValue;
21909 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_err(struct LDKDecodeError e);
21911 export function CResult_SocketAddressDecodeErrorZ_err(e: bigint): bigint {
21912 if(!isWasmInitialized) {
21913 throw new Error("initializeWasm() must be awaited first!");
21915 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_err(e);
21916 return nativeResponseValue;
21918 // bool CResult_SocketAddressDecodeErrorZ_is_ok(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR o);
21920 export function CResult_SocketAddressDecodeErrorZ_is_ok(o: bigint): boolean {
21921 if(!isWasmInitialized) {
21922 throw new Error("initializeWasm() must be awaited first!");
21924 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_is_ok(o);
21925 return nativeResponseValue;
21927 // void CResult_SocketAddressDecodeErrorZ_free(struct LDKCResult_SocketAddressDecodeErrorZ _res);
21929 export function CResult_SocketAddressDecodeErrorZ_free(_res: bigint): void {
21930 if(!isWasmInitialized) {
21931 throw new Error("initializeWasm() must be awaited first!");
21933 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_free(_res);
21934 // debug statements here
21936 // uint64_t CResult_SocketAddressDecodeErrorZ_clone_ptr(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR arg);
21938 export function CResult_SocketAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21939 if(!isWasmInitialized) {
21940 throw new Error("initializeWasm() must be awaited first!");
21942 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone_ptr(arg);
21943 return nativeResponseValue;
21945 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_clone(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR orig);
21947 export function CResult_SocketAddressDecodeErrorZ_clone(orig: bigint): bigint {
21948 if(!isWasmInitialized) {
21949 throw new Error("initializeWasm() must be awaited first!");
21951 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone(orig);
21952 return nativeResponseValue;
21954 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_ok(struct LDKSocketAddress o);
21956 export function CResult_SocketAddressSocketAddressParseErrorZ_ok(o: bigint): bigint {
21957 if(!isWasmInitialized) {
21958 throw new Error("initializeWasm() must be awaited first!");
21960 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_ok(o);
21961 return nativeResponseValue;
21963 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_err(enum LDKSocketAddressParseError e);
21965 export function CResult_SocketAddressSocketAddressParseErrorZ_err(e: SocketAddressParseError): bigint {
21966 if(!isWasmInitialized) {
21967 throw new Error("initializeWasm() must be awaited first!");
21969 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_err(e);
21970 return nativeResponseValue;
21972 // bool CResult_SocketAddressSocketAddressParseErrorZ_is_ok(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR o);
21974 export function CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o: bigint): boolean {
21975 if(!isWasmInitialized) {
21976 throw new Error("initializeWasm() must be awaited first!");
21978 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o);
21979 return nativeResponseValue;
21981 // void CResult_SocketAddressSocketAddressParseErrorZ_free(struct LDKCResult_SocketAddressSocketAddressParseErrorZ _res);
21983 export function CResult_SocketAddressSocketAddressParseErrorZ_free(_res: bigint): void {
21984 if(!isWasmInitialized) {
21985 throw new Error("initializeWasm() must be awaited first!");
21987 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_free(_res);
21988 // debug statements here
21990 // uint64_t CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR arg);
21992 export function CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg: bigint): bigint {
21993 if(!isWasmInitialized) {
21994 throw new Error("initializeWasm() must be awaited first!");
21996 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg);
21997 return nativeResponseValue;
21999 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_clone(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR orig);
22001 export function CResult_SocketAddressSocketAddressParseErrorZ_clone(orig: bigint): bigint {
22002 if(!isWasmInitialized) {
22003 throw new Error("initializeWasm() must be awaited first!");
22005 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone(orig);
22006 return nativeResponseValue;
22008 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
22010 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
22011 if(!isWasmInitialized) {
22012 throw new Error("initializeWasm() must be awaited first!");
22014 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
22015 // debug statements here
22017 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
22019 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
22020 if(!isWasmInitialized) {
22021 throw new Error("initializeWasm() must be awaited first!");
22023 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
22024 // debug statements here
22026 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
22028 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
22029 if(!isWasmInitialized) {
22030 throw new Error("initializeWasm() must be awaited first!");
22032 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
22033 // debug statements here
22035 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
22037 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
22038 if(!isWasmInitialized) {
22039 throw new Error("initializeWasm() must be awaited first!");
22041 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
22042 // debug statements here
22044 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
22046 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
22047 if(!isWasmInitialized) {
22048 throw new Error("initializeWasm() must be awaited first!");
22050 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
22051 return nativeResponseValue;
22053 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
22055 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
22056 if(!isWasmInitialized) {
22057 throw new Error("initializeWasm() must be awaited first!");
22059 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
22060 return nativeResponseValue;
22062 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
22064 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
22065 if(!isWasmInitialized) {
22066 throw new Error("initializeWasm() must be awaited first!");
22068 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
22069 return nativeResponseValue;
22071 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
22073 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
22074 if(!isWasmInitialized) {
22075 throw new Error("initializeWasm() must be awaited first!");
22077 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
22078 // debug statements here
22080 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
22082 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22083 if(!isWasmInitialized) {
22084 throw new Error("initializeWasm() must be awaited first!");
22086 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
22087 return nativeResponseValue;
22089 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
22091 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
22092 if(!isWasmInitialized) {
22093 throw new Error("initializeWasm() must be awaited first!");
22095 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
22096 return nativeResponseValue;
22098 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_ok(struct LDKAcceptChannelV2 o);
22100 export function CResult_AcceptChannelV2DecodeErrorZ_ok(o: bigint): bigint {
22101 if(!isWasmInitialized) {
22102 throw new Error("initializeWasm() must be awaited first!");
22104 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_ok(o);
22105 return nativeResponseValue;
22107 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
22109 export function CResult_AcceptChannelV2DecodeErrorZ_err(e: bigint): bigint {
22110 if(!isWasmInitialized) {
22111 throw new Error("initializeWasm() must be awaited first!");
22113 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_err(e);
22114 return nativeResponseValue;
22116 // bool CResult_AcceptChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR o);
22118 export function CResult_AcceptChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
22119 if(!isWasmInitialized) {
22120 throw new Error("initializeWasm() must be awaited first!");
22122 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(o);
22123 return nativeResponseValue;
22125 // void CResult_AcceptChannelV2DecodeErrorZ_free(struct LDKCResult_AcceptChannelV2DecodeErrorZ _res);
22127 export function CResult_AcceptChannelV2DecodeErrorZ_free(_res: bigint): void {
22128 if(!isWasmInitialized) {
22129 throw new Error("initializeWasm() must be awaited first!");
22131 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_free(_res);
22132 // debug statements here
22134 // uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg);
22136 export function CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
22137 if(!isWasmInitialized) {
22138 throw new Error("initializeWasm() must be awaited first!");
22140 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg);
22141 return nativeResponseValue;
22143 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_clone(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR orig);
22145 export function CResult_AcceptChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
22146 if(!isWasmInitialized) {
22147 throw new Error("initializeWasm() must be awaited first!");
22149 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone(orig);
22150 return nativeResponseValue;
22152 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_ok(struct LDKStfu o);
22154 export function CResult_StfuDecodeErrorZ_ok(o: bigint): bigint {
22155 if(!isWasmInitialized) {
22156 throw new Error("initializeWasm() must be awaited first!");
22158 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_ok(o);
22159 return nativeResponseValue;
22161 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_err(struct LDKDecodeError e);
22163 export function CResult_StfuDecodeErrorZ_err(e: bigint): bigint {
22164 if(!isWasmInitialized) {
22165 throw new Error("initializeWasm() must be awaited first!");
22167 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_err(e);
22168 return nativeResponseValue;
22170 // bool CResult_StfuDecodeErrorZ_is_ok(const struct LDKCResult_StfuDecodeErrorZ *NONNULL_PTR o);
22172 export function CResult_StfuDecodeErrorZ_is_ok(o: bigint): boolean {
22173 if(!isWasmInitialized) {
22174 throw new Error("initializeWasm() must be awaited first!");
22176 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_is_ok(o);
22177 return nativeResponseValue;
22179 // void CResult_StfuDecodeErrorZ_free(struct LDKCResult_StfuDecodeErrorZ _res);
22181 export function CResult_StfuDecodeErrorZ_free(_res: bigint): void {
22182 if(!isWasmInitialized) {
22183 throw new Error("initializeWasm() must be awaited first!");
22185 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_free(_res);
22186 // debug statements here
22188 // uint64_t CResult_StfuDecodeErrorZ_clone_ptr(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR arg);
22190 export function CResult_StfuDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22191 if(!isWasmInitialized) {
22192 throw new Error("initializeWasm() must be awaited first!");
22194 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_clone_ptr(arg);
22195 return nativeResponseValue;
22197 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_clone(const struct LDKCResult_StfuDecodeErrorZ *NONNULL_PTR orig);
22199 export function CResult_StfuDecodeErrorZ_clone(orig: bigint): bigint {
22200 if(!isWasmInitialized) {
22201 throw new Error("initializeWasm() must be awaited first!");
22203 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_clone(orig);
22204 return nativeResponseValue;
22206 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_ok(struct LDKSplice o);
22208 export function CResult_SpliceDecodeErrorZ_ok(o: bigint): bigint {
22209 if(!isWasmInitialized) {
22210 throw new Error("initializeWasm() must be awaited first!");
22212 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_ok(o);
22213 return nativeResponseValue;
22215 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_err(struct LDKDecodeError e);
22217 export function CResult_SpliceDecodeErrorZ_err(e: bigint): bigint {
22218 if(!isWasmInitialized) {
22219 throw new Error("initializeWasm() must be awaited first!");
22221 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_err(e);
22222 return nativeResponseValue;
22224 // bool CResult_SpliceDecodeErrorZ_is_ok(const struct LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR o);
22226 export function CResult_SpliceDecodeErrorZ_is_ok(o: bigint): boolean {
22227 if(!isWasmInitialized) {
22228 throw new Error("initializeWasm() must be awaited first!");
22230 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_is_ok(o);
22231 return nativeResponseValue;
22233 // void CResult_SpliceDecodeErrorZ_free(struct LDKCResult_SpliceDecodeErrorZ _res);
22235 export function CResult_SpliceDecodeErrorZ_free(_res: bigint): void {
22236 if(!isWasmInitialized) {
22237 throw new Error("initializeWasm() must be awaited first!");
22239 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_free(_res);
22240 // debug statements here
22242 // uint64_t CResult_SpliceDecodeErrorZ_clone_ptr(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR arg);
22244 export function CResult_SpliceDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22245 if(!isWasmInitialized) {
22246 throw new Error("initializeWasm() must be awaited first!");
22248 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_clone_ptr(arg);
22249 return nativeResponseValue;
22251 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_clone(const struct LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR orig);
22253 export function CResult_SpliceDecodeErrorZ_clone(orig: bigint): bigint {
22254 if(!isWasmInitialized) {
22255 throw new Error("initializeWasm() must be awaited first!");
22257 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_clone(orig);
22258 return nativeResponseValue;
22260 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_ok(struct LDKSpliceAck o);
22262 export function CResult_SpliceAckDecodeErrorZ_ok(o: bigint): bigint {
22263 if(!isWasmInitialized) {
22264 throw new Error("initializeWasm() must be awaited first!");
22266 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_ok(o);
22267 return nativeResponseValue;
22269 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_err(struct LDKDecodeError e);
22271 export function CResult_SpliceAckDecodeErrorZ_err(e: bigint): bigint {
22272 if(!isWasmInitialized) {
22273 throw new Error("initializeWasm() must be awaited first!");
22275 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_err(e);
22276 return nativeResponseValue;
22278 // bool CResult_SpliceAckDecodeErrorZ_is_ok(const struct LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR o);
22280 export function CResult_SpliceAckDecodeErrorZ_is_ok(o: bigint): boolean {
22281 if(!isWasmInitialized) {
22282 throw new Error("initializeWasm() must be awaited first!");
22284 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_is_ok(o);
22285 return nativeResponseValue;
22287 // void CResult_SpliceAckDecodeErrorZ_free(struct LDKCResult_SpliceAckDecodeErrorZ _res);
22289 export function CResult_SpliceAckDecodeErrorZ_free(_res: bigint): void {
22290 if(!isWasmInitialized) {
22291 throw new Error("initializeWasm() must be awaited first!");
22293 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_free(_res);
22294 // debug statements here
22296 // uint64_t CResult_SpliceAckDecodeErrorZ_clone_ptr(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR arg);
22298 export function CResult_SpliceAckDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22299 if(!isWasmInitialized) {
22300 throw new Error("initializeWasm() must be awaited first!");
22302 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_clone_ptr(arg);
22303 return nativeResponseValue;
22305 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_clone(const struct LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR orig);
22307 export function CResult_SpliceAckDecodeErrorZ_clone(orig: bigint): bigint {
22308 if(!isWasmInitialized) {
22309 throw new Error("initializeWasm() must be awaited first!");
22311 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_clone(orig);
22312 return nativeResponseValue;
22314 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_ok(struct LDKSpliceLocked o);
22316 export function CResult_SpliceLockedDecodeErrorZ_ok(o: bigint): bigint {
22317 if(!isWasmInitialized) {
22318 throw new Error("initializeWasm() must be awaited first!");
22320 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_ok(o);
22321 return nativeResponseValue;
22323 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_err(struct LDKDecodeError e);
22325 export function CResult_SpliceLockedDecodeErrorZ_err(e: bigint): bigint {
22326 if(!isWasmInitialized) {
22327 throw new Error("initializeWasm() must be awaited first!");
22329 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_err(e);
22330 return nativeResponseValue;
22332 // bool CResult_SpliceLockedDecodeErrorZ_is_ok(const struct LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR o);
22334 export function CResult_SpliceLockedDecodeErrorZ_is_ok(o: bigint): boolean {
22335 if(!isWasmInitialized) {
22336 throw new Error("initializeWasm() must be awaited first!");
22338 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_is_ok(o);
22339 return nativeResponseValue;
22341 // void CResult_SpliceLockedDecodeErrorZ_free(struct LDKCResult_SpliceLockedDecodeErrorZ _res);
22343 export function CResult_SpliceLockedDecodeErrorZ_free(_res: bigint): void {
22344 if(!isWasmInitialized) {
22345 throw new Error("initializeWasm() must be awaited first!");
22347 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_free(_res);
22348 // debug statements here
22350 // uint64_t CResult_SpliceLockedDecodeErrorZ_clone_ptr(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR arg);
22352 export function CResult_SpliceLockedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22353 if(!isWasmInitialized) {
22354 throw new Error("initializeWasm() must be awaited first!");
22356 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_clone_ptr(arg);
22357 return nativeResponseValue;
22359 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_clone(const struct LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR orig);
22361 export function CResult_SpliceLockedDecodeErrorZ_clone(orig: bigint): bigint {
22362 if(!isWasmInitialized) {
22363 throw new Error("initializeWasm() must be awaited first!");
22365 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_clone(orig);
22366 return nativeResponseValue;
22368 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_ok(struct LDKTxAddInput o);
22370 export function CResult_TxAddInputDecodeErrorZ_ok(o: bigint): bigint {
22371 if(!isWasmInitialized) {
22372 throw new Error("initializeWasm() must be awaited first!");
22374 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_ok(o);
22375 return nativeResponseValue;
22377 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_err(struct LDKDecodeError e);
22379 export function CResult_TxAddInputDecodeErrorZ_err(e: bigint): bigint {
22380 if(!isWasmInitialized) {
22381 throw new Error("initializeWasm() must be awaited first!");
22383 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_err(e);
22384 return nativeResponseValue;
22386 // bool CResult_TxAddInputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR o);
22388 export function CResult_TxAddInputDecodeErrorZ_is_ok(o: bigint): boolean {
22389 if(!isWasmInitialized) {
22390 throw new Error("initializeWasm() must be awaited first!");
22392 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_is_ok(o);
22393 return nativeResponseValue;
22395 // void CResult_TxAddInputDecodeErrorZ_free(struct LDKCResult_TxAddInputDecodeErrorZ _res);
22397 export function CResult_TxAddInputDecodeErrorZ_free(_res: bigint): void {
22398 if(!isWasmInitialized) {
22399 throw new Error("initializeWasm() must be awaited first!");
22401 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_free(_res);
22402 // debug statements here
22404 // uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg);
22406 export function CResult_TxAddInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22407 if(!isWasmInitialized) {
22408 throw new Error("initializeWasm() must be awaited first!");
22410 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(arg);
22411 return nativeResponseValue;
22413 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_clone(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR orig);
22415 export function CResult_TxAddInputDecodeErrorZ_clone(orig: bigint): bigint {
22416 if(!isWasmInitialized) {
22417 throw new Error("initializeWasm() must be awaited first!");
22419 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone(orig);
22420 return nativeResponseValue;
22422 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_ok(struct LDKTxAddOutput o);
22424 export function CResult_TxAddOutputDecodeErrorZ_ok(o: bigint): bigint {
22425 if(!isWasmInitialized) {
22426 throw new Error("initializeWasm() must be awaited first!");
22428 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_ok(o);
22429 return nativeResponseValue;
22431 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_err(struct LDKDecodeError e);
22433 export function CResult_TxAddOutputDecodeErrorZ_err(e: bigint): bigint {
22434 if(!isWasmInitialized) {
22435 throw new Error("initializeWasm() must be awaited first!");
22437 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_err(e);
22438 return nativeResponseValue;
22440 // bool CResult_TxAddOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR o);
22442 export function CResult_TxAddOutputDecodeErrorZ_is_ok(o: bigint): boolean {
22443 if(!isWasmInitialized) {
22444 throw new Error("initializeWasm() must be awaited first!");
22446 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_is_ok(o);
22447 return nativeResponseValue;
22449 // void CResult_TxAddOutputDecodeErrorZ_free(struct LDKCResult_TxAddOutputDecodeErrorZ _res);
22451 export function CResult_TxAddOutputDecodeErrorZ_free(_res: bigint): void {
22452 if(!isWasmInitialized) {
22453 throw new Error("initializeWasm() must be awaited first!");
22455 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_free(_res);
22456 // debug statements here
22458 // uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg);
22460 export function CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22461 if(!isWasmInitialized) {
22462 throw new Error("initializeWasm() must be awaited first!");
22464 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg);
22465 return nativeResponseValue;
22467 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_clone(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR orig);
22469 export function CResult_TxAddOutputDecodeErrorZ_clone(orig: bigint): bigint {
22470 if(!isWasmInitialized) {
22471 throw new Error("initializeWasm() must be awaited first!");
22473 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone(orig);
22474 return nativeResponseValue;
22476 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_ok(struct LDKTxRemoveInput o);
22478 export function CResult_TxRemoveInputDecodeErrorZ_ok(o: bigint): bigint {
22479 if(!isWasmInitialized) {
22480 throw new Error("initializeWasm() must be awaited first!");
22482 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_ok(o);
22483 return nativeResponseValue;
22485 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_err(struct LDKDecodeError e);
22487 export function CResult_TxRemoveInputDecodeErrorZ_err(e: bigint): bigint {
22488 if(!isWasmInitialized) {
22489 throw new Error("initializeWasm() must be awaited first!");
22491 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_err(e);
22492 return nativeResponseValue;
22494 // bool CResult_TxRemoveInputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR o);
22496 export function CResult_TxRemoveInputDecodeErrorZ_is_ok(o: bigint): boolean {
22497 if(!isWasmInitialized) {
22498 throw new Error("initializeWasm() must be awaited first!");
22500 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(o);
22501 return nativeResponseValue;
22503 // void CResult_TxRemoveInputDecodeErrorZ_free(struct LDKCResult_TxRemoveInputDecodeErrorZ _res);
22505 export function CResult_TxRemoveInputDecodeErrorZ_free(_res: bigint): void {
22506 if(!isWasmInitialized) {
22507 throw new Error("initializeWasm() must be awaited first!");
22509 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_free(_res);
22510 // debug statements here
22512 // uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg);
22514 export function CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22515 if(!isWasmInitialized) {
22516 throw new Error("initializeWasm() must be awaited first!");
22518 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg);
22519 return nativeResponseValue;
22521 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR orig);
22523 export function CResult_TxRemoveInputDecodeErrorZ_clone(orig: bigint): bigint {
22524 if(!isWasmInitialized) {
22525 throw new Error("initializeWasm() must be awaited first!");
22527 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone(orig);
22528 return nativeResponseValue;
22530 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_ok(struct LDKTxRemoveOutput o);
22532 export function CResult_TxRemoveOutputDecodeErrorZ_ok(o: bigint): bigint {
22533 if(!isWasmInitialized) {
22534 throw new Error("initializeWasm() must be awaited first!");
22536 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_ok(o);
22537 return nativeResponseValue;
22539 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_err(struct LDKDecodeError e);
22541 export function CResult_TxRemoveOutputDecodeErrorZ_err(e: bigint): bigint {
22542 if(!isWasmInitialized) {
22543 throw new Error("initializeWasm() must be awaited first!");
22545 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_err(e);
22546 return nativeResponseValue;
22548 // bool CResult_TxRemoveOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR o);
22550 export function CResult_TxRemoveOutputDecodeErrorZ_is_ok(o: bigint): boolean {
22551 if(!isWasmInitialized) {
22552 throw new Error("initializeWasm() must be awaited first!");
22554 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(o);
22555 return nativeResponseValue;
22557 // void CResult_TxRemoveOutputDecodeErrorZ_free(struct LDKCResult_TxRemoveOutputDecodeErrorZ _res);
22559 export function CResult_TxRemoveOutputDecodeErrorZ_free(_res: bigint): void {
22560 if(!isWasmInitialized) {
22561 throw new Error("initializeWasm() must be awaited first!");
22563 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_free(_res);
22564 // debug statements here
22566 // uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg);
22568 export function CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22569 if(!isWasmInitialized) {
22570 throw new Error("initializeWasm() must be awaited first!");
22572 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg);
22573 return nativeResponseValue;
22575 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR orig);
22577 export function CResult_TxRemoveOutputDecodeErrorZ_clone(orig: bigint): bigint {
22578 if(!isWasmInitialized) {
22579 throw new Error("initializeWasm() must be awaited first!");
22581 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone(orig);
22582 return nativeResponseValue;
22584 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_ok(struct LDKTxComplete o);
22586 export function CResult_TxCompleteDecodeErrorZ_ok(o: bigint): bigint {
22587 if(!isWasmInitialized) {
22588 throw new Error("initializeWasm() must be awaited first!");
22590 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_ok(o);
22591 return nativeResponseValue;
22593 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_err(struct LDKDecodeError e);
22595 export function CResult_TxCompleteDecodeErrorZ_err(e: bigint): bigint {
22596 if(!isWasmInitialized) {
22597 throw new Error("initializeWasm() must be awaited first!");
22599 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_err(e);
22600 return nativeResponseValue;
22602 // bool CResult_TxCompleteDecodeErrorZ_is_ok(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR o);
22604 export function CResult_TxCompleteDecodeErrorZ_is_ok(o: bigint): boolean {
22605 if(!isWasmInitialized) {
22606 throw new Error("initializeWasm() must be awaited first!");
22608 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_is_ok(o);
22609 return nativeResponseValue;
22611 // void CResult_TxCompleteDecodeErrorZ_free(struct LDKCResult_TxCompleteDecodeErrorZ _res);
22613 export function CResult_TxCompleteDecodeErrorZ_free(_res: bigint): void {
22614 if(!isWasmInitialized) {
22615 throw new Error("initializeWasm() must be awaited first!");
22617 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_free(_res);
22618 // debug statements here
22620 // uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg);
22622 export function CResult_TxCompleteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22623 if(!isWasmInitialized) {
22624 throw new Error("initializeWasm() must be awaited first!");
22626 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(arg);
22627 return nativeResponseValue;
22629 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_clone(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR orig);
22631 export function CResult_TxCompleteDecodeErrorZ_clone(orig: bigint): bigint {
22632 if(!isWasmInitialized) {
22633 throw new Error("initializeWasm() must be awaited first!");
22635 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone(orig);
22636 return nativeResponseValue;
22638 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_ok(struct LDKTxSignatures o);
22640 export function CResult_TxSignaturesDecodeErrorZ_ok(o: bigint): bigint {
22641 if(!isWasmInitialized) {
22642 throw new Error("initializeWasm() must be awaited first!");
22644 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_ok(o);
22645 return nativeResponseValue;
22647 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
22649 export function CResult_TxSignaturesDecodeErrorZ_err(e: bigint): bigint {
22650 if(!isWasmInitialized) {
22651 throw new Error("initializeWasm() must be awaited first!");
22653 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_err(e);
22654 return nativeResponseValue;
22656 // bool CResult_TxSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR o);
22658 export function CResult_TxSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
22659 if(!isWasmInitialized) {
22660 throw new Error("initializeWasm() must be awaited first!");
22662 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_is_ok(o);
22663 return nativeResponseValue;
22665 // void CResult_TxSignaturesDecodeErrorZ_free(struct LDKCResult_TxSignaturesDecodeErrorZ _res);
22667 export function CResult_TxSignaturesDecodeErrorZ_free(_res: bigint): void {
22668 if(!isWasmInitialized) {
22669 throw new Error("initializeWasm() must be awaited first!");
22671 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_free(_res);
22672 // debug statements here
22674 // uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg);
22676 export function CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22677 if(!isWasmInitialized) {
22678 throw new Error("initializeWasm() must be awaited first!");
22680 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg);
22681 return nativeResponseValue;
22683 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_clone(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR orig);
22685 export function CResult_TxSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
22686 if(!isWasmInitialized) {
22687 throw new Error("initializeWasm() must be awaited first!");
22689 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone(orig);
22690 return nativeResponseValue;
22692 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_ok(struct LDKTxInitRbf o);
22694 export function CResult_TxInitRbfDecodeErrorZ_ok(o: bigint): bigint {
22695 if(!isWasmInitialized) {
22696 throw new Error("initializeWasm() must be awaited first!");
22698 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_ok(o);
22699 return nativeResponseValue;
22701 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_err(struct LDKDecodeError e);
22703 export function CResult_TxInitRbfDecodeErrorZ_err(e: bigint): bigint {
22704 if(!isWasmInitialized) {
22705 throw new Error("initializeWasm() must be awaited first!");
22707 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_err(e);
22708 return nativeResponseValue;
22710 // bool CResult_TxInitRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR o);
22712 export function CResult_TxInitRbfDecodeErrorZ_is_ok(o: bigint): boolean {
22713 if(!isWasmInitialized) {
22714 throw new Error("initializeWasm() must be awaited first!");
22716 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_is_ok(o);
22717 return nativeResponseValue;
22719 // void CResult_TxInitRbfDecodeErrorZ_free(struct LDKCResult_TxInitRbfDecodeErrorZ _res);
22721 export function CResult_TxInitRbfDecodeErrorZ_free(_res: bigint): void {
22722 if(!isWasmInitialized) {
22723 throw new Error("initializeWasm() must be awaited first!");
22725 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_free(_res);
22726 // debug statements here
22728 // uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg);
22730 export function CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22731 if(!isWasmInitialized) {
22732 throw new Error("initializeWasm() must be awaited first!");
22734 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg);
22735 return nativeResponseValue;
22737 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_clone(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR orig);
22739 export function CResult_TxInitRbfDecodeErrorZ_clone(orig: bigint): bigint {
22740 if(!isWasmInitialized) {
22741 throw new Error("initializeWasm() must be awaited first!");
22743 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone(orig);
22744 return nativeResponseValue;
22746 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_ok(struct LDKTxAckRbf o);
22748 export function CResult_TxAckRbfDecodeErrorZ_ok(o: bigint): bigint {
22749 if(!isWasmInitialized) {
22750 throw new Error("initializeWasm() must be awaited first!");
22752 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_ok(o);
22753 return nativeResponseValue;
22755 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_err(struct LDKDecodeError e);
22757 export function CResult_TxAckRbfDecodeErrorZ_err(e: bigint): bigint {
22758 if(!isWasmInitialized) {
22759 throw new Error("initializeWasm() must be awaited first!");
22761 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_err(e);
22762 return nativeResponseValue;
22764 // bool CResult_TxAckRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR o);
22766 export function CResult_TxAckRbfDecodeErrorZ_is_ok(o: bigint): boolean {
22767 if(!isWasmInitialized) {
22768 throw new Error("initializeWasm() must be awaited first!");
22770 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_is_ok(o);
22771 return nativeResponseValue;
22773 // void CResult_TxAckRbfDecodeErrorZ_free(struct LDKCResult_TxAckRbfDecodeErrorZ _res);
22775 export function CResult_TxAckRbfDecodeErrorZ_free(_res: bigint): void {
22776 if(!isWasmInitialized) {
22777 throw new Error("initializeWasm() must be awaited first!");
22779 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_free(_res);
22780 // debug statements here
22782 // uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg);
22784 export function CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22785 if(!isWasmInitialized) {
22786 throw new Error("initializeWasm() must be awaited first!");
22788 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg);
22789 return nativeResponseValue;
22791 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_clone(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR orig);
22793 export function CResult_TxAckRbfDecodeErrorZ_clone(orig: bigint): bigint {
22794 if(!isWasmInitialized) {
22795 throw new Error("initializeWasm() must be awaited first!");
22797 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone(orig);
22798 return nativeResponseValue;
22800 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_ok(struct LDKTxAbort o);
22802 export function CResult_TxAbortDecodeErrorZ_ok(o: bigint): bigint {
22803 if(!isWasmInitialized) {
22804 throw new Error("initializeWasm() must be awaited first!");
22806 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_ok(o);
22807 return nativeResponseValue;
22809 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_err(struct LDKDecodeError e);
22811 export function CResult_TxAbortDecodeErrorZ_err(e: bigint): bigint {
22812 if(!isWasmInitialized) {
22813 throw new Error("initializeWasm() must be awaited first!");
22815 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_err(e);
22816 return nativeResponseValue;
22818 // bool CResult_TxAbortDecodeErrorZ_is_ok(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR o);
22820 export function CResult_TxAbortDecodeErrorZ_is_ok(o: bigint): boolean {
22821 if(!isWasmInitialized) {
22822 throw new Error("initializeWasm() must be awaited first!");
22824 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_is_ok(o);
22825 return nativeResponseValue;
22827 // void CResult_TxAbortDecodeErrorZ_free(struct LDKCResult_TxAbortDecodeErrorZ _res);
22829 export function CResult_TxAbortDecodeErrorZ_free(_res: bigint): void {
22830 if(!isWasmInitialized) {
22831 throw new Error("initializeWasm() must be awaited first!");
22833 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_free(_res);
22834 // debug statements here
22836 // uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg);
22838 export function CResult_TxAbortDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22839 if(!isWasmInitialized) {
22840 throw new Error("initializeWasm() must be awaited first!");
22842 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone_ptr(arg);
22843 return nativeResponseValue;
22845 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_clone(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR orig);
22847 export function CResult_TxAbortDecodeErrorZ_clone(orig: bigint): bigint {
22848 if(!isWasmInitialized) {
22849 throw new Error("initializeWasm() must be awaited first!");
22851 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone(orig);
22852 return nativeResponseValue;
22854 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
22856 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
22857 if(!isWasmInitialized) {
22858 throw new Error("initializeWasm() must be awaited first!");
22860 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
22861 return nativeResponseValue;
22863 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
22865 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
22866 if(!isWasmInitialized) {
22867 throw new Error("initializeWasm() must be awaited first!");
22869 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
22870 return nativeResponseValue;
22872 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
22874 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
22875 if(!isWasmInitialized) {
22876 throw new Error("initializeWasm() must be awaited first!");
22878 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
22879 return nativeResponseValue;
22881 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
22883 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
22884 if(!isWasmInitialized) {
22885 throw new Error("initializeWasm() must be awaited first!");
22887 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
22888 // debug statements here
22890 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
22892 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22893 if(!isWasmInitialized) {
22894 throw new Error("initializeWasm() must be awaited first!");
22896 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
22897 return nativeResponseValue;
22899 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
22901 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
22902 if(!isWasmInitialized) {
22903 throw new Error("initializeWasm() must be awaited first!");
22905 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
22906 return nativeResponseValue;
22908 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
22910 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
22911 if(!isWasmInitialized) {
22912 throw new Error("initializeWasm() must be awaited first!");
22914 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
22915 return nativeResponseValue;
22917 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
22919 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
22920 if(!isWasmInitialized) {
22921 throw new Error("initializeWasm() must be awaited first!");
22923 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
22924 return nativeResponseValue;
22926 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
22928 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
22929 if(!isWasmInitialized) {
22930 throw new Error("initializeWasm() must be awaited first!");
22932 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
22933 return nativeResponseValue;
22935 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
22937 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
22938 if(!isWasmInitialized) {
22939 throw new Error("initializeWasm() must be awaited first!");
22941 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
22942 // debug statements here
22944 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
22946 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22947 if(!isWasmInitialized) {
22948 throw new Error("initializeWasm() must be awaited first!");
22950 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
22951 return nativeResponseValue;
22953 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
22955 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
22956 if(!isWasmInitialized) {
22957 throw new Error("initializeWasm() must be awaited first!");
22959 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
22960 return nativeResponseValue;
22962 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
22964 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
22965 if(!isWasmInitialized) {
22966 throw new Error("initializeWasm() must be awaited first!");
22968 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
22969 return nativeResponseValue;
22971 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
22973 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
22974 if(!isWasmInitialized) {
22975 throw new Error("initializeWasm() must be awaited first!");
22977 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
22978 return nativeResponseValue;
22980 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
22982 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
22983 if(!isWasmInitialized) {
22984 throw new Error("initializeWasm() must be awaited first!");
22986 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
22987 return nativeResponseValue;
22989 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
22991 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
22992 if(!isWasmInitialized) {
22993 throw new Error("initializeWasm() must be awaited first!");
22995 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
22996 // debug statements here
22998 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
23000 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23001 if(!isWasmInitialized) {
23002 throw new Error("initializeWasm() must be awaited first!");
23004 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
23005 return nativeResponseValue;
23007 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
23009 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
23010 if(!isWasmInitialized) {
23011 throw new Error("initializeWasm() must be awaited first!");
23013 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
23014 return nativeResponseValue;
23016 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
23018 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
23019 if(!isWasmInitialized) {
23020 throw new Error("initializeWasm() must be awaited first!");
23022 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
23023 return nativeResponseValue;
23025 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
23027 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
23028 if(!isWasmInitialized) {
23029 throw new Error("initializeWasm() must be awaited first!");
23031 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
23032 return nativeResponseValue;
23034 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
23036 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
23037 if(!isWasmInitialized) {
23038 throw new Error("initializeWasm() must be awaited first!");
23040 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
23041 return nativeResponseValue;
23043 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
23045 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
23046 if(!isWasmInitialized) {
23047 throw new Error("initializeWasm() must be awaited first!");
23049 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
23050 // debug statements here
23052 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
23054 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23055 if(!isWasmInitialized) {
23056 throw new Error("initializeWasm() must be awaited first!");
23058 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
23059 return nativeResponseValue;
23061 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
23063 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
23064 if(!isWasmInitialized) {
23065 throw new Error("initializeWasm() must be awaited first!");
23067 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
23068 return nativeResponseValue;
23070 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
23072 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
23073 if(!isWasmInitialized) {
23074 throw new Error("initializeWasm() must be awaited first!");
23076 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
23077 return nativeResponseValue;
23079 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
23081 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
23082 if(!isWasmInitialized) {
23083 throw new Error("initializeWasm() must be awaited first!");
23085 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
23086 return nativeResponseValue;
23088 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
23090 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
23091 if(!isWasmInitialized) {
23092 throw new Error("initializeWasm() must be awaited first!");
23094 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
23095 return nativeResponseValue;
23097 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
23099 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
23100 if(!isWasmInitialized) {
23101 throw new Error("initializeWasm() must be awaited first!");
23103 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
23104 // debug statements here
23106 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
23108 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23109 if(!isWasmInitialized) {
23110 throw new Error("initializeWasm() must be awaited first!");
23112 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
23113 return nativeResponseValue;
23115 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
23117 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
23118 if(!isWasmInitialized) {
23119 throw new Error("initializeWasm() must be awaited first!");
23121 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
23122 return nativeResponseValue;
23124 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
23126 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
23127 if(!isWasmInitialized) {
23128 throw new Error("initializeWasm() must be awaited first!");
23130 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
23131 return nativeResponseValue;
23133 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
23135 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
23136 if(!isWasmInitialized) {
23137 throw new Error("initializeWasm() must be awaited first!");
23139 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
23140 return nativeResponseValue;
23142 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
23144 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
23145 if(!isWasmInitialized) {
23146 throw new Error("initializeWasm() must be awaited first!");
23148 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
23149 return nativeResponseValue;
23151 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
23153 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
23154 if(!isWasmInitialized) {
23155 throw new Error("initializeWasm() must be awaited first!");
23157 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
23158 // debug statements here
23160 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
23162 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23163 if(!isWasmInitialized) {
23164 throw new Error("initializeWasm() must be awaited first!");
23166 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
23167 return nativeResponseValue;
23169 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
23171 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
23172 if(!isWasmInitialized) {
23173 throw new Error("initializeWasm() must be awaited first!");
23175 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
23176 return nativeResponseValue;
23178 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
23180 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
23181 if(!isWasmInitialized) {
23182 throw new Error("initializeWasm() must be awaited first!");
23184 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
23185 return nativeResponseValue;
23187 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
23189 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
23190 if(!isWasmInitialized) {
23191 throw new Error("initializeWasm() must be awaited first!");
23193 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
23194 return nativeResponseValue;
23196 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
23198 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
23199 if(!isWasmInitialized) {
23200 throw new Error("initializeWasm() must be awaited first!");
23202 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
23203 return nativeResponseValue;
23205 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
23207 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
23208 if(!isWasmInitialized) {
23209 throw new Error("initializeWasm() must be awaited first!");
23211 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
23212 // debug statements here
23214 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
23216 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23217 if(!isWasmInitialized) {
23218 throw new Error("initializeWasm() must be awaited first!");
23220 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
23221 return nativeResponseValue;
23223 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
23225 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
23226 if(!isWasmInitialized) {
23227 throw new Error("initializeWasm() must be awaited first!");
23229 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
23230 return nativeResponseValue;
23232 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
23234 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
23235 if(!isWasmInitialized) {
23236 throw new Error("initializeWasm() must be awaited first!");
23238 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
23239 return nativeResponseValue;
23241 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
23243 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
23244 if(!isWasmInitialized) {
23245 throw new Error("initializeWasm() must be awaited first!");
23247 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
23248 return nativeResponseValue;
23250 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
23252 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
23253 if(!isWasmInitialized) {
23254 throw new Error("initializeWasm() must be awaited first!");
23256 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
23257 return nativeResponseValue;
23259 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
23261 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
23262 if(!isWasmInitialized) {
23263 throw new Error("initializeWasm() must be awaited first!");
23265 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
23266 // debug statements here
23268 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
23270 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23271 if(!isWasmInitialized) {
23272 throw new Error("initializeWasm() must be awaited first!");
23274 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
23275 return nativeResponseValue;
23277 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
23279 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
23280 if(!isWasmInitialized) {
23281 throw new Error("initializeWasm() must be awaited first!");
23283 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
23284 return nativeResponseValue;
23286 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
23288 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
23289 if(!isWasmInitialized) {
23290 throw new Error("initializeWasm() must be awaited first!");
23292 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
23293 return nativeResponseValue;
23295 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
23297 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
23298 if(!isWasmInitialized) {
23299 throw new Error("initializeWasm() must be awaited first!");
23301 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
23302 return nativeResponseValue;
23304 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
23306 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
23307 if(!isWasmInitialized) {
23308 throw new Error("initializeWasm() must be awaited first!");
23310 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
23311 return nativeResponseValue;
23313 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
23315 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
23316 if(!isWasmInitialized) {
23317 throw new Error("initializeWasm() must be awaited first!");
23319 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
23320 // debug statements here
23322 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
23324 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23325 if(!isWasmInitialized) {
23326 throw new Error("initializeWasm() must be awaited first!");
23328 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
23329 return nativeResponseValue;
23331 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
23333 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
23334 if(!isWasmInitialized) {
23335 throw new Error("initializeWasm() must be awaited first!");
23337 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
23338 return nativeResponseValue;
23340 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
23342 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
23343 if(!isWasmInitialized) {
23344 throw new Error("initializeWasm() must be awaited first!");
23346 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
23347 return nativeResponseValue;
23349 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
23351 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
23352 if(!isWasmInitialized) {
23353 throw new Error("initializeWasm() must be awaited first!");
23355 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
23356 return nativeResponseValue;
23358 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
23360 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
23361 if(!isWasmInitialized) {
23362 throw new Error("initializeWasm() must be awaited first!");
23364 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
23365 return nativeResponseValue;
23367 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
23369 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
23370 if(!isWasmInitialized) {
23371 throw new Error("initializeWasm() must be awaited first!");
23373 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
23374 // debug statements here
23376 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
23378 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23379 if(!isWasmInitialized) {
23380 throw new Error("initializeWasm() must be awaited first!");
23382 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
23383 return nativeResponseValue;
23385 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
23387 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
23388 if(!isWasmInitialized) {
23389 throw new Error("initializeWasm() must be awaited first!");
23391 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
23392 return nativeResponseValue;
23394 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_ok(struct LDKOpenChannelV2 o);
23396 export function CResult_OpenChannelV2DecodeErrorZ_ok(o: bigint): bigint {
23397 if(!isWasmInitialized) {
23398 throw new Error("initializeWasm() must be awaited first!");
23400 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_ok(o);
23401 return nativeResponseValue;
23403 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
23405 export function CResult_OpenChannelV2DecodeErrorZ_err(e: bigint): bigint {
23406 if(!isWasmInitialized) {
23407 throw new Error("initializeWasm() must be awaited first!");
23409 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_err(e);
23410 return nativeResponseValue;
23412 // bool CResult_OpenChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR o);
23414 export function CResult_OpenChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
23415 if(!isWasmInitialized) {
23416 throw new Error("initializeWasm() must be awaited first!");
23418 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(o);
23419 return nativeResponseValue;
23421 // void CResult_OpenChannelV2DecodeErrorZ_free(struct LDKCResult_OpenChannelV2DecodeErrorZ _res);
23423 export function CResult_OpenChannelV2DecodeErrorZ_free(_res: bigint): void {
23424 if(!isWasmInitialized) {
23425 throw new Error("initializeWasm() must be awaited first!");
23427 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_free(_res);
23428 // debug statements here
23430 // uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg);
23432 export function CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
23433 if(!isWasmInitialized) {
23434 throw new Error("initializeWasm() must be awaited first!");
23436 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg);
23437 return nativeResponseValue;
23439 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_clone(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR orig);
23441 export function CResult_OpenChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
23442 if(!isWasmInitialized) {
23443 throw new Error("initializeWasm() must be awaited first!");
23445 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone(orig);
23446 return nativeResponseValue;
23448 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
23450 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
23451 if(!isWasmInitialized) {
23452 throw new Error("initializeWasm() must be awaited first!");
23454 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
23455 return nativeResponseValue;
23457 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
23459 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
23460 if(!isWasmInitialized) {
23461 throw new Error("initializeWasm() must be awaited first!");
23463 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
23464 return nativeResponseValue;
23466 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
23468 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
23469 if(!isWasmInitialized) {
23470 throw new Error("initializeWasm() must be awaited first!");
23472 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
23473 return nativeResponseValue;
23475 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
23477 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
23478 if(!isWasmInitialized) {
23479 throw new Error("initializeWasm() must be awaited first!");
23481 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
23482 // debug statements here
23484 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
23486 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23487 if(!isWasmInitialized) {
23488 throw new Error("initializeWasm() must be awaited first!");
23490 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
23491 return nativeResponseValue;
23493 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
23495 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
23496 if(!isWasmInitialized) {
23497 throw new Error("initializeWasm() must be awaited first!");
23499 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
23500 return nativeResponseValue;
23502 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
23504 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
23505 if(!isWasmInitialized) {
23506 throw new Error("initializeWasm() must be awaited first!");
23508 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
23509 return nativeResponseValue;
23511 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
23513 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
23514 if(!isWasmInitialized) {
23515 throw new Error("initializeWasm() must be awaited first!");
23517 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
23518 return nativeResponseValue;
23520 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
23522 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
23523 if(!isWasmInitialized) {
23524 throw new Error("initializeWasm() must be awaited first!");
23526 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
23527 return nativeResponseValue;
23529 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
23531 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
23532 if(!isWasmInitialized) {
23533 throw new Error("initializeWasm() must be awaited first!");
23535 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
23536 // debug statements here
23538 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
23540 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23541 if(!isWasmInitialized) {
23542 throw new Error("initializeWasm() must be awaited first!");
23544 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
23545 return nativeResponseValue;
23547 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
23549 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
23550 if(!isWasmInitialized) {
23551 throw new Error("initializeWasm() must be awaited first!");
23553 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
23554 return nativeResponseValue;
23556 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
23558 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
23559 if(!isWasmInitialized) {
23560 throw new Error("initializeWasm() must be awaited first!");
23562 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
23563 return nativeResponseValue;
23565 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
23567 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
23568 if(!isWasmInitialized) {
23569 throw new Error("initializeWasm() must be awaited first!");
23571 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
23572 return nativeResponseValue;
23574 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
23576 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
23577 if(!isWasmInitialized) {
23578 throw new Error("initializeWasm() must be awaited first!");
23580 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
23581 return nativeResponseValue;
23583 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
23585 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
23586 if(!isWasmInitialized) {
23587 throw new Error("initializeWasm() must be awaited first!");
23589 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
23590 // debug statements here
23592 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
23594 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23595 if(!isWasmInitialized) {
23596 throw new Error("initializeWasm() must be awaited first!");
23598 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
23599 return nativeResponseValue;
23601 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
23603 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
23604 if(!isWasmInitialized) {
23605 throw new Error("initializeWasm() must be awaited first!");
23607 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
23608 return nativeResponseValue;
23610 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
23612 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
23613 if(!isWasmInitialized) {
23614 throw new Error("initializeWasm() must be awaited first!");
23616 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
23617 return nativeResponseValue;
23619 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
23621 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
23622 if(!isWasmInitialized) {
23623 throw new Error("initializeWasm() must be awaited first!");
23625 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
23626 return nativeResponseValue;
23628 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
23630 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
23631 if(!isWasmInitialized) {
23632 throw new Error("initializeWasm() must be awaited first!");
23634 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
23635 return nativeResponseValue;
23637 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
23639 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
23640 if(!isWasmInitialized) {
23641 throw new Error("initializeWasm() must be awaited first!");
23643 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
23644 // debug statements here
23646 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
23648 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23649 if(!isWasmInitialized) {
23650 throw new Error("initializeWasm() must be awaited first!");
23652 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
23653 return nativeResponseValue;
23655 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
23657 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
23658 if(!isWasmInitialized) {
23659 throw new Error("initializeWasm() must be awaited first!");
23661 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
23662 return nativeResponseValue;
23664 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
23666 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
23667 if(!isWasmInitialized) {
23668 throw new Error("initializeWasm() must be awaited first!");
23670 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
23671 return nativeResponseValue;
23673 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
23675 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
23676 if(!isWasmInitialized) {
23677 throw new Error("initializeWasm() must be awaited first!");
23679 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
23680 return nativeResponseValue;
23682 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
23684 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
23685 if(!isWasmInitialized) {
23686 throw new Error("initializeWasm() must be awaited first!");
23688 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
23689 return nativeResponseValue;
23691 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
23693 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
23694 if(!isWasmInitialized) {
23695 throw new Error("initializeWasm() must be awaited first!");
23697 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
23698 // debug statements here
23700 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
23702 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23703 if(!isWasmInitialized) {
23704 throw new Error("initializeWasm() must be awaited first!");
23706 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
23707 return nativeResponseValue;
23709 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
23711 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
23712 if(!isWasmInitialized) {
23713 throw new Error("initializeWasm() must be awaited first!");
23715 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
23716 return nativeResponseValue;
23718 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
23720 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
23721 if(!isWasmInitialized) {
23722 throw new Error("initializeWasm() must be awaited first!");
23724 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
23725 return nativeResponseValue;
23727 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
23729 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
23730 if(!isWasmInitialized) {
23731 throw new Error("initializeWasm() must be awaited first!");
23733 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
23734 return nativeResponseValue;
23736 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
23738 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
23739 if(!isWasmInitialized) {
23740 throw new Error("initializeWasm() must be awaited first!");
23742 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
23743 return nativeResponseValue;
23745 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
23747 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
23748 if(!isWasmInitialized) {
23749 throw new Error("initializeWasm() must be awaited first!");
23751 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
23752 // debug statements here
23754 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
23756 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23757 if(!isWasmInitialized) {
23758 throw new Error("initializeWasm() must be awaited first!");
23760 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
23761 return nativeResponseValue;
23763 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
23765 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
23766 if(!isWasmInitialized) {
23767 throw new Error("initializeWasm() must be awaited first!");
23769 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
23770 return nativeResponseValue;
23772 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_ok(struct LDKOnionPacket o);
23774 export function CResult_OnionPacketDecodeErrorZ_ok(o: bigint): bigint {
23775 if(!isWasmInitialized) {
23776 throw new Error("initializeWasm() must be awaited first!");
23778 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_ok(o);
23779 return nativeResponseValue;
23781 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_err(struct LDKDecodeError e);
23783 export function CResult_OnionPacketDecodeErrorZ_err(e: bigint): bigint {
23784 if(!isWasmInitialized) {
23785 throw new Error("initializeWasm() must be awaited first!");
23787 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_err(e);
23788 return nativeResponseValue;
23790 // bool CResult_OnionPacketDecodeErrorZ_is_ok(const struct LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR o);
23792 export function CResult_OnionPacketDecodeErrorZ_is_ok(o: bigint): boolean {
23793 if(!isWasmInitialized) {
23794 throw new Error("initializeWasm() must be awaited first!");
23796 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_is_ok(o);
23797 return nativeResponseValue;
23799 // void CResult_OnionPacketDecodeErrorZ_free(struct LDKCResult_OnionPacketDecodeErrorZ _res);
23801 export function CResult_OnionPacketDecodeErrorZ_free(_res: bigint): void {
23802 if(!isWasmInitialized) {
23803 throw new Error("initializeWasm() must be awaited first!");
23805 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_free(_res);
23806 // debug statements here
23808 // uint64_t CResult_OnionPacketDecodeErrorZ_clone_ptr(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR arg);
23810 export function CResult_OnionPacketDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23811 if(!isWasmInitialized) {
23812 throw new Error("initializeWasm() must be awaited first!");
23814 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_clone_ptr(arg);
23815 return nativeResponseValue;
23817 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_clone(const struct LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR orig);
23819 export function CResult_OnionPacketDecodeErrorZ_clone(orig: bigint): bigint {
23820 if(!isWasmInitialized) {
23821 throw new Error("initializeWasm() must be awaited first!");
23823 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_clone(orig);
23824 return nativeResponseValue;
23826 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
23828 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
23829 if(!isWasmInitialized) {
23830 throw new Error("initializeWasm() must be awaited first!");
23832 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
23833 return nativeResponseValue;
23835 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
23837 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
23838 if(!isWasmInitialized) {
23839 throw new Error("initializeWasm() must be awaited first!");
23841 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
23842 return nativeResponseValue;
23844 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
23846 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
23847 if(!isWasmInitialized) {
23848 throw new Error("initializeWasm() must be awaited first!");
23850 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
23851 return nativeResponseValue;
23853 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
23855 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
23856 if(!isWasmInitialized) {
23857 throw new Error("initializeWasm() must be awaited first!");
23859 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
23860 // debug statements here
23862 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
23864 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23865 if(!isWasmInitialized) {
23866 throw new Error("initializeWasm() must be awaited first!");
23868 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
23869 return nativeResponseValue;
23871 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
23873 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
23874 if(!isWasmInitialized) {
23875 throw new Error("initializeWasm() must be awaited first!");
23877 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
23878 return nativeResponseValue;
23880 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
23882 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
23883 if(!isWasmInitialized) {
23884 throw new Error("initializeWasm() must be awaited first!");
23886 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
23887 return nativeResponseValue;
23889 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
23891 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
23892 if(!isWasmInitialized) {
23893 throw new Error("initializeWasm() must be awaited first!");
23895 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
23896 return nativeResponseValue;
23898 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
23900 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
23901 if(!isWasmInitialized) {
23902 throw new Error("initializeWasm() must be awaited first!");
23904 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
23905 return nativeResponseValue;
23907 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
23909 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
23910 if(!isWasmInitialized) {
23911 throw new Error("initializeWasm() must be awaited first!");
23913 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
23914 // debug statements here
23916 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
23918 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23919 if(!isWasmInitialized) {
23920 throw new Error("initializeWasm() must be awaited first!");
23922 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
23923 return nativeResponseValue;
23925 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
23927 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
23928 if(!isWasmInitialized) {
23929 throw new Error("initializeWasm() must be awaited first!");
23931 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
23932 return nativeResponseValue;
23934 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_ok(struct LDKFinalOnionHopData o);
23936 export function CResult_FinalOnionHopDataDecodeErrorZ_ok(o: bigint): bigint {
23937 if(!isWasmInitialized) {
23938 throw new Error("initializeWasm() must be awaited first!");
23940 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_ok(o);
23941 return nativeResponseValue;
23943 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_err(struct LDKDecodeError e);
23945 export function CResult_FinalOnionHopDataDecodeErrorZ_err(e: bigint): bigint {
23946 if(!isWasmInitialized) {
23947 throw new Error("initializeWasm() must be awaited first!");
23949 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_err(e);
23950 return nativeResponseValue;
23952 // bool CResult_FinalOnionHopDataDecodeErrorZ_is_ok(const struct LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR o);
23954 export function CResult_FinalOnionHopDataDecodeErrorZ_is_ok(o: bigint): boolean {
23955 if(!isWasmInitialized) {
23956 throw new Error("initializeWasm() must be awaited first!");
23958 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_is_ok(o);
23959 return nativeResponseValue;
23961 // void CResult_FinalOnionHopDataDecodeErrorZ_free(struct LDKCResult_FinalOnionHopDataDecodeErrorZ _res);
23963 export function CResult_FinalOnionHopDataDecodeErrorZ_free(_res: bigint): void {
23964 if(!isWasmInitialized) {
23965 throw new Error("initializeWasm() must be awaited first!");
23967 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_free(_res);
23968 // debug statements here
23970 // uint64_t CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR arg);
23972 export function CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23973 if(!isWasmInitialized) {
23974 throw new Error("initializeWasm() must be awaited first!");
23976 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(arg);
23977 return nativeResponseValue;
23979 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_clone(const struct LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR orig);
23981 export function CResult_FinalOnionHopDataDecodeErrorZ_clone(orig: bigint): bigint {
23982 if(!isWasmInitialized) {
23983 throw new Error("initializeWasm() must be awaited first!");
23985 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_clone(orig);
23986 return nativeResponseValue;
23988 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
23990 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
23991 if(!isWasmInitialized) {
23992 throw new Error("initializeWasm() must be awaited first!");
23994 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
23995 return nativeResponseValue;
23997 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
23999 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
24000 if(!isWasmInitialized) {
24001 throw new Error("initializeWasm() must be awaited first!");
24003 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
24004 return nativeResponseValue;
24006 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
24008 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
24009 if(!isWasmInitialized) {
24010 throw new Error("initializeWasm() must be awaited first!");
24012 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
24013 return nativeResponseValue;
24015 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
24017 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
24018 if(!isWasmInitialized) {
24019 throw new Error("initializeWasm() must be awaited first!");
24021 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
24022 // debug statements here
24024 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
24026 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24027 if(!isWasmInitialized) {
24028 throw new Error("initializeWasm() must be awaited first!");
24030 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
24031 return nativeResponseValue;
24033 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
24035 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
24036 if(!isWasmInitialized) {
24037 throw new Error("initializeWasm() must be awaited first!");
24039 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
24040 return nativeResponseValue;
24042 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
24044 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
24045 if(!isWasmInitialized) {
24046 throw new Error("initializeWasm() must be awaited first!");
24048 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
24049 return nativeResponseValue;
24051 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
24053 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
24054 if(!isWasmInitialized) {
24055 throw new Error("initializeWasm() must be awaited first!");
24057 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
24058 return nativeResponseValue;
24060 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
24062 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
24063 if(!isWasmInitialized) {
24064 throw new Error("initializeWasm() must be awaited first!");
24066 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
24067 return nativeResponseValue;
24069 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
24071 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
24072 if(!isWasmInitialized) {
24073 throw new Error("initializeWasm() must be awaited first!");
24075 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
24076 // debug statements here
24078 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
24080 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24081 if(!isWasmInitialized) {
24082 throw new Error("initializeWasm() must be awaited first!");
24084 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
24085 return nativeResponseValue;
24087 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
24089 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
24090 if(!isWasmInitialized) {
24091 throw new Error("initializeWasm() must be awaited first!");
24093 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
24094 return nativeResponseValue;
24096 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
24098 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
24099 if(!isWasmInitialized) {
24100 throw new Error("initializeWasm() must be awaited first!");
24102 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
24103 return nativeResponseValue;
24105 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
24107 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
24108 if(!isWasmInitialized) {
24109 throw new Error("initializeWasm() must be awaited first!");
24111 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
24112 return nativeResponseValue;
24114 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
24116 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
24117 if(!isWasmInitialized) {
24118 throw new Error("initializeWasm() must be awaited first!");
24120 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
24121 return nativeResponseValue;
24123 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
24125 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
24126 if(!isWasmInitialized) {
24127 throw new Error("initializeWasm() must be awaited first!");
24129 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
24130 // debug statements here
24132 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
24134 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24135 if(!isWasmInitialized) {
24136 throw new Error("initializeWasm() must be awaited first!");
24138 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
24139 return nativeResponseValue;
24141 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
24143 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
24144 if(!isWasmInitialized) {
24145 throw new Error("initializeWasm() must be awaited first!");
24147 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
24148 return nativeResponseValue;
24150 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
24152 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
24153 if(!isWasmInitialized) {
24154 throw new Error("initializeWasm() must be awaited first!");
24156 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
24157 return nativeResponseValue;
24159 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
24161 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
24162 if(!isWasmInitialized) {
24163 throw new Error("initializeWasm() must be awaited first!");
24165 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
24166 return nativeResponseValue;
24168 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
24170 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
24171 if(!isWasmInitialized) {
24172 throw new Error("initializeWasm() must be awaited first!");
24174 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
24175 return nativeResponseValue;
24177 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
24179 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
24180 if(!isWasmInitialized) {
24181 throw new Error("initializeWasm() must be awaited first!");
24183 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
24184 // debug statements here
24186 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
24188 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24189 if(!isWasmInitialized) {
24190 throw new Error("initializeWasm() must be awaited first!");
24192 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
24193 return nativeResponseValue;
24195 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
24197 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
24198 if(!isWasmInitialized) {
24199 throw new Error("initializeWasm() must be awaited first!");
24201 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
24202 return nativeResponseValue;
24204 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
24206 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
24207 if(!isWasmInitialized) {
24208 throw new Error("initializeWasm() must be awaited first!");
24210 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
24211 return nativeResponseValue;
24213 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
24215 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
24216 if(!isWasmInitialized) {
24217 throw new Error("initializeWasm() must be awaited first!");
24219 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
24220 return nativeResponseValue;
24222 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
24224 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
24225 if(!isWasmInitialized) {
24226 throw new Error("initializeWasm() must be awaited first!");
24228 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
24229 return nativeResponseValue;
24231 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
24233 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
24234 if(!isWasmInitialized) {
24235 throw new Error("initializeWasm() must be awaited first!");
24237 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
24238 // debug statements here
24240 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
24242 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24243 if(!isWasmInitialized) {
24244 throw new Error("initializeWasm() must be awaited first!");
24246 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
24247 return nativeResponseValue;
24249 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
24251 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
24252 if(!isWasmInitialized) {
24253 throw new Error("initializeWasm() must be awaited first!");
24255 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
24256 return nativeResponseValue;
24258 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
24260 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
24261 if(!isWasmInitialized) {
24262 throw new Error("initializeWasm() must be awaited first!");
24264 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
24265 return nativeResponseValue;
24267 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
24269 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
24270 if(!isWasmInitialized) {
24271 throw new Error("initializeWasm() must be awaited first!");
24273 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
24274 return nativeResponseValue;
24276 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
24278 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
24279 if(!isWasmInitialized) {
24280 throw new Error("initializeWasm() must be awaited first!");
24282 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
24283 return nativeResponseValue;
24285 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
24287 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
24288 if(!isWasmInitialized) {
24289 throw new Error("initializeWasm() must be awaited first!");
24291 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
24292 // debug statements here
24294 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
24296 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24297 if(!isWasmInitialized) {
24298 throw new Error("initializeWasm() must be awaited first!");
24300 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
24301 return nativeResponseValue;
24303 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
24305 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
24306 if(!isWasmInitialized) {
24307 throw new Error("initializeWasm() must be awaited first!");
24309 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
24310 return nativeResponseValue;
24312 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
24314 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
24315 if(!isWasmInitialized) {
24316 throw new Error("initializeWasm() must be awaited first!");
24318 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
24319 return nativeResponseValue;
24321 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
24323 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
24324 if(!isWasmInitialized) {
24325 throw new Error("initializeWasm() must be awaited first!");
24327 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
24328 return nativeResponseValue;
24330 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
24332 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
24333 if(!isWasmInitialized) {
24334 throw new Error("initializeWasm() must be awaited first!");
24336 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
24337 return nativeResponseValue;
24339 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
24341 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
24342 if(!isWasmInitialized) {
24343 throw new Error("initializeWasm() must be awaited first!");
24345 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
24346 // debug statements here
24348 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
24350 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24351 if(!isWasmInitialized) {
24352 throw new Error("initializeWasm() must be awaited first!");
24354 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
24355 return nativeResponseValue;
24357 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
24359 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
24360 if(!isWasmInitialized) {
24361 throw new Error("initializeWasm() must be awaited first!");
24363 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
24364 return nativeResponseValue;
24366 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
24368 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
24369 if(!isWasmInitialized) {
24370 throw new Error("initializeWasm() must be awaited first!");
24372 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
24373 return nativeResponseValue;
24375 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
24377 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
24378 if(!isWasmInitialized) {
24379 throw new Error("initializeWasm() must be awaited first!");
24381 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
24382 return nativeResponseValue;
24384 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
24386 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
24387 if(!isWasmInitialized) {
24388 throw new Error("initializeWasm() must be awaited first!");
24390 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
24391 return nativeResponseValue;
24393 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
24395 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
24396 if(!isWasmInitialized) {
24397 throw new Error("initializeWasm() must be awaited first!");
24399 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
24400 // debug statements here
24402 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
24404 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24405 if(!isWasmInitialized) {
24406 throw new Error("initializeWasm() must be awaited first!");
24408 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
24409 return nativeResponseValue;
24411 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
24413 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
24414 if(!isWasmInitialized) {
24415 throw new Error("initializeWasm() must be awaited first!");
24417 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
24418 return nativeResponseValue;
24420 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
24422 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
24423 if(!isWasmInitialized) {
24424 throw new Error("initializeWasm() must be awaited first!");
24426 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
24427 return nativeResponseValue;
24429 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
24431 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
24432 if(!isWasmInitialized) {
24433 throw new Error("initializeWasm() must be awaited first!");
24435 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
24436 return nativeResponseValue;
24438 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
24440 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
24441 if(!isWasmInitialized) {
24442 throw new Error("initializeWasm() must be awaited first!");
24444 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
24445 return nativeResponseValue;
24447 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
24449 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
24450 if(!isWasmInitialized) {
24451 throw new Error("initializeWasm() must be awaited first!");
24453 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
24454 // debug statements here
24456 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
24458 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24459 if(!isWasmInitialized) {
24460 throw new Error("initializeWasm() must be awaited first!");
24462 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
24463 return nativeResponseValue;
24465 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
24467 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
24468 if(!isWasmInitialized) {
24469 throw new Error("initializeWasm() must be awaited first!");
24471 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
24472 return nativeResponseValue;
24474 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
24476 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
24477 if(!isWasmInitialized) {
24478 throw new Error("initializeWasm() must be awaited first!");
24480 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
24481 return nativeResponseValue;
24483 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
24485 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
24486 if(!isWasmInitialized) {
24487 throw new Error("initializeWasm() must be awaited first!");
24489 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
24490 return nativeResponseValue;
24492 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
24494 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
24495 if(!isWasmInitialized) {
24496 throw new Error("initializeWasm() must be awaited first!");
24498 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
24499 return nativeResponseValue;
24501 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
24503 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
24504 if(!isWasmInitialized) {
24505 throw new Error("initializeWasm() must be awaited first!");
24507 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
24508 // debug statements here
24510 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
24512 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24513 if(!isWasmInitialized) {
24514 throw new Error("initializeWasm() must be awaited first!");
24516 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
24517 return nativeResponseValue;
24519 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
24521 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
24522 if(!isWasmInitialized) {
24523 throw new Error("initializeWasm() must be awaited first!");
24525 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
24526 return nativeResponseValue;
24528 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
24530 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
24531 if(!isWasmInitialized) {
24532 throw new Error("initializeWasm() must be awaited first!");
24534 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
24535 return nativeResponseValue;
24537 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
24539 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
24540 if(!isWasmInitialized) {
24541 throw new Error("initializeWasm() must be awaited first!");
24543 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
24544 return nativeResponseValue;
24546 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
24548 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
24549 if(!isWasmInitialized) {
24550 throw new Error("initializeWasm() must be awaited first!");
24552 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
24553 return nativeResponseValue;
24555 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
24557 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
24558 if(!isWasmInitialized) {
24559 throw new Error("initializeWasm() must be awaited first!");
24561 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
24562 // debug statements here
24564 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
24566 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24567 if(!isWasmInitialized) {
24568 throw new Error("initializeWasm() must be awaited first!");
24570 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
24571 return nativeResponseValue;
24573 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
24575 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
24576 if(!isWasmInitialized) {
24577 throw new Error("initializeWasm() must be awaited first!");
24579 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
24580 return nativeResponseValue;
24582 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
24584 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
24585 if(!isWasmInitialized) {
24586 throw new Error("initializeWasm() must be awaited first!");
24588 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
24589 return nativeResponseValue;
24591 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
24593 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
24594 if(!isWasmInitialized) {
24595 throw new Error("initializeWasm() must be awaited first!");
24597 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
24598 return nativeResponseValue;
24600 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
24602 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
24603 if(!isWasmInitialized) {
24604 throw new Error("initializeWasm() must be awaited first!");
24606 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
24607 return nativeResponseValue;
24609 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
24611 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
24612 if(!isWasmInitialized) {
24613 throw new Error("initializeWasm() must be awaited first!");
24615 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
24616 // debug statements here
24618 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
24620 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24621 if(!isWasmInitialized) {
24622 throw new Error("initializeWasm() must be awaited first!");
24624 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
24625 return nativeResponseValue;
24627 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
24629 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
24630 if(!isWasmInitialized) {
24631 throw new Error("initializeWasm() must be awaited first!");
24633 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
24634 return nativeResponseValue;
24636 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
24638 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
24639 if(!isWasmInitialized) {
24640 throw new Error("initializeWasm() must be awaited first!");
24642 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
24643 return nativeResponseValue;
24645 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
24647 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
24648 if(!isWasmInitialized) {
24649 throw new Error("initializeWasm() must be awaited first!");
24651 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
24652 return nativeResponseValue;
24654 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
24656 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
24657 if(!isWasmInitialized) {
24658 throw new Error("initializeWasm() must be awaited first!");
24660 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
24661 return nativeResponseValue;
24663 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
24665 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
24666 if(!isWasmInitialized) {
24667 throw new Error("initializeWasm() must be awaited first!");
24669 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
24670 // debug statements here
24672 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
24674 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24675 if(!isWasmInitialized) {
24676 throw new Error("initializeWasm() must be awaited first!");
24678 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
24679 return nativeResponseValue;
24681 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
24683 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
24684 if(!isWasmInitialized) {
24685 throw new Error("initializeWasm() must be awaited first!");
24687 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
24688 return nativeResponseValue;
24690 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
24692 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
24693 if(!isWasmInitialized) {
24694 throw new Error("initializeWasm() must be awaited first!");
24696 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
24697 return nativeResponseValue;
24699 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
24701 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
24702 if(!isWasmInitialized) {
24703 throw new Error("initializeWasm() must be awaited first!");
24705 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
24706 return nativeResponseValue;
24708 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
24710 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
24711 if(!isWasmInitialized) {
24712 throw new Error("initializeWasm() must be awaited first!");
24714 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
24715 return nativeResponseValue;
24717 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
24719 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
24720 if(!isWasmInitialized) {
24721 throw new Error("initializeWasm() must be awaited first!");
24723 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
24724 // debug statements here
24726 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
24728 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24729 if(!isWasmInitialized) {
24730 throw new Error("initializeWasm() must be awaited first!");
24732 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
24733 return nativeResponseValue;
24735 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
24737 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
24738 if(!isWasmInitialized) {
24739 throw new Error("initializeWasm() must be awaited first!");
24741 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
24742 return nativeResponseValue;
24744 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
24746 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
24747 if(!isWasmInitialized) {
24748 throw new Error("initializeWasm() must be awaited first!");
24750 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
24751 return nativeResponseValue;
24753 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
24755 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
24756 if(!isWasmInitialized) {
24757 throw new Error("initializeWasm() must be awaited first!");
24759 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
24760 return nativeResponseValue;
24762 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
24764 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
24765 if(!isWasmInitialized) {
24766 throw new Error("initializeWasm() must be awaited first!");
24768 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
24769 return nativeResponseValue;
24771 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
24773 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
24774 if(!isWasmInitialized) {
24775 throw new Error("initializeWasm() must be awaited first!");
24777 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
24778 // debug statements here
24780 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
24782 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24783 if(!isWasmInitialized) {
24784 throw new Error("initializeWasm() must be awaited first!");
24786 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
24787 return nativeResponseValue;
24789 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
24791 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
24792 if(!isWasmInitialized) {
24793 throw new Error("initializeWasm() must be awaited first!");
24795 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
24796 return nativeResponseValue;
24798 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
24800 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
24801 if(!isWasmInitialized) {
24802 throw new Error("initializeWasm() must be awaited first!");
24804 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
24805 // debug statements here
24807 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(struct LDKBolt11Invoice o);
24809 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
24810 if(!isWasmInitialized) {
24811 throw new Error("initializeWasm() must be awaited first!");
24813 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o);
24814 return nativeResponseValue;
24816 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
24818 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
24819 if(!isWasmInitialized) {
24820 throw new Error("initializeWasm() must be awaited first!");
24822 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e);
24823 return nativeResponseValue;
24825 // bool CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
24827 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
24828 if(!isWasmInitialized) {
24829 throw new Error("initializeWasm() must be awaited first!");
24831 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o);
24832 return nativeResponseValue;
24834 // void CResult_Bolt11InvoiceSignOrCreationErrorZ_free(struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res);
24836 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
24837 if(!isWasmInitialized) {
24838 throw new Error("initializeWasm() must be awaited first!");
24840 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res);
24841 // debug statements here
24843 // uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
24845 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
24846 if(!isWasmInitialized) {
24847 throw new Error("initializeWasm() must be awaited first!");
24849 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg);
24850 return nativeResponseValue;
24852 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
24854 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
24855 if(!isWasmInitialized) {
24856 throw new Error("initializeWasm() must be awaited first!");
24858 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
24859 return nativeResponseValue;
24861 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
24863 export function CResult_OffersMessageDecodeErrorZ_ok(o: bigint): bigint {
24864 if(!isWasmInitialized) {
24865 throw new Error("initializeWasm() must be awaited first!");
24867 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_ok(o);
24868 return nativeResponseValue;
24870 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_err(struct LDKDecodeError e);
24872 export function CResult_OffersMessageDecodeErrorZ_err(e: bigint): bigint {
24873 if(!isWasmInitialized) {
24874 throw new Error("initializeWasm() must be awaited first!");
24876 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_err(e);
24877 return nativeResponseValue;
24879 // bool CResult_OffersMessageDecodeErrorZ_is_ok(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR o);
24881 export function CResult_OffersMessageDecodeErrorZ_is_ok(o: bigint): boolean {
24882 if(!isWasmInitialized) {
24883 throw new Error("initializeWasm() must be awaited first!");
24885 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_is_ok(o);
24886 return nativeResponseValue;
24888 // void CResult_OffersMessageDecodeErrorZ_free(struct LDKCResult_OffersMessageDecodeErrorZ _res);
24890 export function CResult_OffersMessageDecodeErrorZ_free(_res: bigint): void {
24891 if(!isWasmInitialized) {
24892 throw new Error("initializeWasm() must be awaited first!");
24894 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_free(_res);
24895 // debug statements here
24897 // uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg);
24899 export function CResult_OffersMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24900 if(!isWasmInitialized) {
24901 throw new Error("initializeWasm() must be awaited first!");
24903 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(arg);
24904 return nativeResponseValue;
24906 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_clone(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR orig);
24908 export function CResult_OffersMessageDecodeErrorZ_clone(orig: bigint): bigint {
24909 if(!isWasmInitialized) {
24910 throw new Error("initializeWasm() must be awaited first!");
24912 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone(orig);
24913 return nativeResponseValue;
24915 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
24917 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
24918 if(!isWasmInitialized) {
24919 throw new Error("initializeWasm() must be awaited first!");
24921 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
24922 return nativeResponseValue;
24924 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
24926 export function COption_HTLCClaimZ_none(): bigint {
24927 if(!isWasmInitialized) {
24928 throw new Error("initializeWasm() must be awaited first!");
24930 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
24931 return nativeResponseValue;
24933 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
24935 export function COption_HTLCClaimZ_free(_res: bigint): void {
24936 if(!isWasmInitialized) {
24937 throw new Error("initializeWasm() must be awaited first!");
24939 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
24940 // debug statements here
24942 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
24944 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
24945 if(!isWasmInitialized) {
24946 throw new Error("initializeWasm() must be awaited first!");
24948 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
24949 return nativeResponseValue;
24951 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
24953 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
24954 if(!isWasmInitialized) {
24955 throw new Error("initializeWasm() must be awaited first!");
24957 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
24958 return nativeResponseValue;
24960 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
24962 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
24963 if(!isWasmInitialized) {
24964 throw new Error("initializeWasm() must be awaited first!");
24966 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
24967 return nativeResponseValue;
24969 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
24971 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
24972 if(!isWasmInitialized) {
24973 throw new Error("initializeWasm() must be awaited first!");
24975 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
24976 // debug statements here
24978 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
24980 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24981 if(!isWasmInitialized) {
24982 throw new Error("initializeWasm() must be awaited first!");
24984 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
24985 return nativeResponseValue;
24987 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
24989 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
24990 if(!isWasmInitialized) {
24991 throw new Error("initializeWasm() must be awaited first!");
24993 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
24994 return nativeResponseValue;
24996 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
24998 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
24999 if(!isWasmInitialized) {
25000 throw new Error("initializeWasm() must be awaited first!");
25002 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
25003 return nativeResponseValue;
25005 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
25007 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
25008 if(!isWasmInitialized) {
25009 throw new Error("initializeWasm() must be awaited first!");
25011 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
25012 return nativeResponseValue;
25014 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
25016 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
25017 if(!isWasmInitialized) {
25018 throw new Error("initializeWasm() must be awaited first!");
25020 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
25021 return nativeResponseValue;
25023 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
25025 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
25026 if(!isWasmInitialized) {
25027 throw new Error("initializeWasm() must be awaited first!");
25029 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
25030 // debug statements here
25032 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
25034 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25035 if(!isWasmInitialized) {
25036 throw new Error("initializeWasm() must be awaited first!");
25038 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
25039 return nativeResponseValue;
25041 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
25043 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
25044 if(!isWasmInitialized) {
25045 throw new Error("initializeWasm() must be awaited first!");
25047 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
25048 return nativeResponseValue;
25050 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
25052 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
25053 if(!isWasmInitialized) {
25054 throw new Error("initializeWasm() must be awaited first!");
25056 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
25057 return nativeResponseValue;
25059 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
25061 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
25062 if(!isWasmInitialized) {
25063 throw new Error("initializeWasm() must be awaited first!");
25065 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
25066 return nativeResponseValue;
25068 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
25070 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
25071 if(!isWasmInitialized) {
25072 throw new Error("initializeWasm() must be awaited first!");
25074 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
25075 return nativeResponseValue;
25077 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
25079 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
25080 if(!isWasmInitialized) {
25081 throw new Error("initializeWasm() must be awaited first!");
25083 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
25084 // debug statements here
25086 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
25088 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25089 if(!isWasmInitialized) {
25090 throw new Error("initializeWasm() must be awaited first!");
25092 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
25093 return nativeResponseValue;
25095 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
25097 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
25098 if(!isWasmInitialized) {
25099 throw new Error("initializeWasm() must be awaited first!");
25101 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
25102 return nativeResponseValue;
25104 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
25106 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
25107 if(!isWasmInitialized) {
25108 throw new Error("initializeWasm() must be awaited first!");
25110 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
25111 return nativeResponseValue;
25113 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
25115 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
25116 if(!isWasmInitialized) {
25117 throw new Error("initializeWasm() must be awaited first!");
25119 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
25120 return nativeResponseValue;
25122 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
25124 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
25125 if(!isWasmInitialized) {
25126 throw new Error("initializeWasm() must be awaited first!");
25128 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
25129 return nativeResponseValue;
25131 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
25133 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
25134 if(!isWasmInitialized) {
25135 throw new Error("initializeWasm() must be awaited first!");
25137 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
25138 // debug statements here
25140 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
25142 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25143 if(!isWasmInitialized) {
25144 throw new Error("initializeWasm() must be awaited first!");
25146 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
25147 return nativeResponseValue;
25149 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
25151 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
25152 if(!isWasmInitialized) {
25153 throw new Error("initializeWasm() must be awaited first!");
25155 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
25156 return nativeResponseValue;
25158 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
25160 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
25161 if(!isWasmInitialized) {
25162 throw new Error("initializeWasm() must be awaited first!");
25164 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
25165 return nativeResponseValue;
25167 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
25169 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
25170 if(!isWasmInitialized) {
25171 throw new Error("initializeWasm() must be awaited first!");
25173 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
25174 return nativeResponseValue;
25176 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
25178 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
25179 if(!isWasmInitialized) {
25180 throw new Error("initializeWasm() must be awaited first!");
25182 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
25183 return nativeResponseValue;
25185 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
25187 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
25188 if(!isWasmInitialized) {
25189 throw new Error("initializeWasm() must be awaited first!");
25191 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
25192 // debug statements here
25194 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
25196 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25197 if(!isWasmInitialized) {
25198 throw new Error("initializeWasm() must be awaited first!");
25200 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
25201 return nativeResponseValue;
25203 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
25205 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
25206 if(!isWasmInitialized) {
25207 throw new Error("initializeWasm() must be awaited first!");
25209 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
25210 return nativeResponseValue;
25212 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
25214 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
25215 if(!isWasmInitialized) {
25216 throw new Error("initializeWasm() must be awaited first!");
25218 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
25219 return nativeResponseValue;
25221 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
25223 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
25224 if(!isWasmInitialized) {
25225 throw new Error("initializeWasm() must be awaited first!");
25227 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
25228 return nativeResponseValue;
25230 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
25232 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
25233 if(!isWasmInitialized) {
25234 throw new Error("initializeWasm() must be awaited first!");
25236 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
25237 return nativeResponseValue;
25239 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
25241 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
25242 if(!isWasmInitialized) {
25243 throw new Error("initializeWasm() must be awaited first!");
25245 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
25246 // debug statements here
25248 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
25250 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25251 if(!isWasmInitialized) {
25252 throw new Error("initializeWasm() must be awaited first!");
25254 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
25255 return nativeResponseValue;
25257 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
25259 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
25260 if(!isWasmInitialized) {
25261 throw new Error("initializeWasm() must be awaited first!");
25263 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
25264 return nativeResponseValue;
25266 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
25268 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
25269 if(!isWasmInitialized) {
25270 throw new Error("initializeWasm() must be awaited first!");
25272 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
25273 return nativeResponseValue;
25275 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
25277 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
25278 if(!isWasmInitialized) {
25279 throw new Error("initializeWasm() must be awaited first!");
25281 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
25282 return nativeResponseValue;
25284 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
25286 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
25287 if(!isWasmInitialized) {
25288 throw new Error("initializeWasm() must be awaited first!");
25290 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
25291 return nativeResponseValue;
25293 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
25295 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
25296 if(!isWasmInitialized) {
25297 throw new Error("initializeWasm() must be awaited first!");
25299 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
25300 // debug statements here
25302 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
25304 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25305 if(!isWasmInitialized) {
25306 throw new Error("initializeWasm() must be awaited first!");
25308 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
25309 return nativeResponseValue;
25311 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
25313 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
25314 if(!isWasmInitialized) {
25315 throw new Error("initializeWasm() must be awaited first!");
25317 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
25318 return nativeResponseValue;
25320 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
25322 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
25323 if(!isWasmInitialized) {
25324 throw new Error("initializeWasm() must be awaited first!");
25326 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
25327 return nativeResponseValue;
25329 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
25331 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
25332 if(!isWasmInitialized) {
25333 throw new Error("initializeWasm() must be awaited first!");
25335 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
25336 return nativeResponseValue;
25338 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
25340 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
25341 if(!isWasmInitialized) {
25342 throw new Error("initializeWasm() must be awaited first!");
25344 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
25345 return nativeResponseValue;
25347 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
25349 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
25350 if(!isWasmInitialized) {
25351 throw new Error("initializeWasm() must be awaited first!");
25353 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
25354 // debug statements here
25356 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
25358 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25359 if(!isWasmInitialized) {
25360 throw new Error("initializeWasm() must be awaited first!");
25362 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
25363 return nativeResponseValue;
25365 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
25367 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
25368 if(!isWasmInitialized) {
25369 throw new Error("initializeWasm() must be awaited first!");
25371 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
25372 return nativeResponseValue;
25374 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
25376 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
25377 if(!isWasmInitialized) {
25378 throw new Error("initializeWasm() must be awaited first!");
25380 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
25381 return nativeResponseValue;
25383 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
25385 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
25386 if(!isWasmInitialized) {
25387 throw new Error("initializeWasm() must be awaited first!");
25389 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
25390 return nativeResponseValue;
25392 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
25394 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
25395 if(!isWasmInitialized) {
25396 throw new Error("initializeWasm() must be awaited first!");
25398 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
25399 return nativeResponseValue;
25401 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
25403 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
25404 if(!isWasmInitialized) {
25405 throw new Error("initializeWasm() must be awaited first!");
25407 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
25408 // debug statements here
25410 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
25412 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
25413 if(!isWasmInitialized) {
25414 throw new Error("initializeWasm() must be awaited first!");
25416 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
25417 return nativeResponseValue;
25419 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
25421 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
25422 if(!isWasmInitialized) {
25423 throw new Error("initializeWasm() must be awaited first!");
25425 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
25426 return nativeResponseValue;
25428 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
25430 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
25431 if(!isWasmInitialized) {
25432 throw new Error("initializeWasm() must be awaited first!");
25434 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
25435 return nativeResponseValue;
25437 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
25439 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
25440 if(!isWasmInitialized) {
25441 throw new Error("initializeWasm() must be awaited first!");
25443 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
25444 // debug statements here
25446 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
25448 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25449 if(!isWasmInitialized) {
25450 throw new Error("initializeWasm() must be awaited first!");
25452 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
25453 return nativeResponseValue;
25455 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
25457 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
25458 if(!isWasmInitialized) {
25459 throw new Error("initializeWasm() must be awaited first!");
25461 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
25462 return nativeResponseValue;
25464 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
25466 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
25467 if(!isWasmInitialized) {
25468 throw new Error("initializeWasm() must be awaited first!");
25470 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
25471 return nativeResponseValue;
25473 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
25475 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
25476 if(!isWasmInitialized) {
25477 throw new Error("initializeWasm() must be awaited first!");
25479 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
25480 return nativeResponseValue;
25482 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
25484 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
25485 if(!isWasmInitialized) {
25486 throw new Error("initializeWasm() must be awaited first!");
25488 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
25489 return nativeResponseValue;
25491 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
25493 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
25494 if(!isWasmInitialized) {
25495 throw new Error("initializeWasm() must be awaited first!");
25497 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
25498 // debug statements here
25500 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_ok(struct LDKCVec_ECDSASignatureZ o);
25502 export function CResult_CVec_ECDSASignatureZNoneZ_ok(o: number): bigint {
25503 if(!isWasmInitialized) {
25504 throw new Error("initializeWasm() must be awaited first!");
25506 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_ok(o);
25507 return nativeResponseValue;
25509 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_err(void);
25511 export function CResult_CVec_ECDSASignatureZNoneZ_err(): bigint {
25512 if(!isWasmInitialized) {
25513 throw new Error("initializeWasm() must be awaited first!");
25515 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_err();
25516 return nativeResponseValue;
25518 // bool CResult_CVec_ECDSASignatureZNoneZ_is_ok(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR o);
25520 export function CResult_CVec_ECDSASignatureZNoneZ_is_ok(o: bigint): boolean {
25521 if(!isWasmInitialized) {
25522 throw new Error("initializeWasm() must be awaited first!");
25524 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok(o);
25525 return nativeResponseValue;
25527 // void CResult_CVec_ECDSASignatureZNoneZ_free(struct LDKCResult_CVec_ECDSASignatureZNoneZ _res);
25529 export function CResult_CVec_ECDSASignatureZNoneZ_free(_res: bigint): void {
25530 if(!isWasmInitialized) {
25531 throw new Error("initializeWasm() must be awaited first!");
25533 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_free(_res);
25534 // debug statements here
25536 // uint64_t CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR arg);
25538 export function CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg: bigint): bigint {
25539 if(!isWasmInitialized) {
25540 throw new Error("initializeWasm() must be awaited first!");
25542 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg);
25543 return nativeResponseValue;
25545 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_clone(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR orig);
25547 export function CResult_CVec_ECDSASignatureZNoneZ_clone(orig: bigint): bigint {
25548 if(!isWasmInitialized) {
25549 throw new Error("initializeWasm() must be awaited first!");
25551 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone(orig);
25552 return nativeResponseValue;
25554 // struct LDKCOption_usizeZ COption_usizeZ_some(uintptr_t o);
25556 export function COption_usizeZ_some(o: number): bigint {
25557 if(!isWasmInitialized) {
25558 throw new Error("initializeWasm() must be awaited first!");
25560 const nativeResponseValue = wasm.TS_COption_usizeZ_some(o);
25561 return nativeResponseValue;
25563 // struct LDKCOption_usizeZ COption_usizeZ_none(void);
25565 export function COption_usizeZ_none(): bigint {
25566 if(!isWasmInitialized) {
25567 throw new Error("initializeWasm() must be awaited first!");
25569 const nativeResponseValue = wasm.TS_COption_usizeZ_none();
25570 return nativeResponseValue;
25572 // void COption_usizeZ_free(struct LDKCOption_usizeZ _res);
25574 export function COption_usizeZ_free(_res: bigint): void {
25575 if(!isWasmInitialized) {
25576 throw new Error("initializeWasm() must be awaited first!");
25578 const nativeResponseValue = wasm.TS_COption_usizeZ_free(_res);
25579 // debug statements here
25581 // uint64_t COption_usizeZ_clone_ptr(LDKCOption_usizeZ *NONNULL_PTR arg);
25583 export function COption_usizeZ_clone_ptr(arg: bigint): bigint {
25584 if(!isWasmInitialized) {
25585 throw new Error("initializeWasm() must be awaited first!");
25587 const nativeResponseValue = wasm.TS_COption_usizeZ_clone_ptr(arg);
25588 return nativeResponseValue;
25590 // struct LDKCOption_usizeZ COption_usizeZ_clone(const struct LDKCOption_usizeZ *NONNULL_PTR orig);
25592 export function COption_usizeZ_clone(orig: bigint): bigint {
25593 if(!isWasmInitialized) {
25594 throw new Error("initializeWasm() must be awaited first!");
25596 const nativeResponseValue = wasm.TS_COption_usizeZ_clone(orig);
25597 return nativeResponseValue;
25599 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
25601 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
25602 if(!isWasmInitialized) {
25603 throw new Error("initializeWasm() must be awaited first!");
25605 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
25606 return nativeResponseValue;
25608 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
25610 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
25611 if(!isWasmInitialized) {
25612 throw new Error("initializeWasm() must be awaited first!");
25614 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
25615 return nativeResponseValue;
25617 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
25619 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
25620 if(!isWasmInitialized) {
25621 throw new Error("initializeWasm() must be awaited first!");
25623 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
25624 return nativeResponseValue;
25626 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
25628 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
25629 if(!isWasmInitialized) {
25630 throw new Error("initializeWasm() must be awaited first!");
25632 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
25633 // debug statements here
25635 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
25637 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25638 if(!isWasmInitialized) {
25639 throw new Error("initializeWasm() must be awaited first!");
25641 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
25642 return nativeResponseValue;
25644 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
25646 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
25647 if(!isWasmInitialized) {
25648 throw new Error("initializeWasm() must be awaited first!");
25650 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
25651 return nativeResponseValue;
25653 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
25655 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
25656 if(!isWasmInitialized) {
25657 throw new Error("initializeWasm() must be awaited first!");
25659 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
25660 return nativeResponseValue;
25662 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
25664 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
25665 if(!isWasmInitialized) {
25666 throw new Error("initializeWasm() must be awaited first!");
25668 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
25669 return nativeResponseValue;
25671 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
25673 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
25674 if(!isWasmInitialized) {
25675 throw new Error("initializeWasm() must be awaited first!");
25677 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
25678 return nativeResponseValue;
25680 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
25682 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
25683 if(!isWasmInitialized) {
25684 throw new Error("initializeWasm() must be awaited first!");
25686 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
25687 // debug statements here
25689 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
25691 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
25692 if(!isWasmInitialized) {
25693 throw new Error("initializeWasm() must be awaited first!");
25695 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
25696 return nativeResponseValue;
25698 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
25700 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
25701 if(!isWasmInitialized) {
25702 throw new Error("initializeWasm() must be awaited first!");
25704 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
25705 return nativeResponseValue;
25707 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
25709 export function CVec_TransactionZ_free(_res: number): void {
25710 if(!isWasmInitialized) {
25711 throw new Error("initializeWasm() must be awaited first!");
25713 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
25714 // debug statements here
25716 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
25718 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
25719 if(!isWasmInitialized) {
25720 throw new Error("initializeWasm() must be awaited first!");
25722 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
25723 return nativeResponseValue;
25725 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
25727 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
25728 if(!isWasmInitialized) {
25729 throw new Error("initializeWasm() must be awaited first!");
25731 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
25732 return nativeResponseValue;
25734 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
25736 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
25737 if(!isWasmInitialized) {
25738 throw new Error("initializeWasm() must be awaited first!");
25740 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
25741 return nativeResponseValue;
25743 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
25745 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
25746 if(!isWasmInitialized) {
25747 throw new Error("initializeWasm() must be awaited first!");
25749 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
25750 // debug statements here
25752 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
25754 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25755 if(!isWasmInitialized) {
25756 throw new Error("initializeWasm() must be awaited first!");
25758 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
25759 return nativeResponseValue;
25761 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
25763 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
25764 if(!isWasmInitialized) {
25765 throw new Error("initializeWasm() must be awaited first!");
25767 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
25768 return nativeResponseValue;
25770 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_ok(struct LDKClaimedHTLC o);
25772 export function CResult_ClaimedHTLCDecodeErrorZ_ok(o: bigint): bigint {
25773 if(!isWasmInitialized) {
25774 throw new Error("initializeWasm() must be awaited first!");
25776 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_ok(o);
25777 return nativeResponseValue;
25779 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
25781 export function CResult_ClaimedHTLCDecodeErrorZ_err(e: bigint): bigint {
25782 if(!isWasmInitialized) {
25783 throw new Error("initializeWasm() must be awaited first!");
25785 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_err(e);
25786 return nativeResponseValue;
25788 // bool CResult_ClaimedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR o);
25790 export function CResult_ClaimedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
25791 if(!isWasmInitialized) {
25792 throw new Error("initializeWasm() must be awaited first!");
25794 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok(o);
25795 return nativeResponseValue;
25797 // void CResult_ClaimedHTLCDecodeErrorZ_free(struct LDKCResult_ClaimedHTLCDecodeErrorZ _res);
25799 export function CResult_ClaimedHTLCDecodeErrorZ_free(_res: bigint): void {
25800 if(!isWasmInitialized) {
25801 throw new Error("initializeWasm() must be awaited first!");
25803 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_free(_res);
25804 // debug statements here
25806 // uint64_t CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR arg);
25808 export function CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25809 if(!isWasmInitialized) {
25810 throw new Error("initializeWasm() must be awaited first!");
25812 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg);
25813 return nativeResponseValue;
25815 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_clone(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR orig);
25817 export function CResult_ClaimedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
25818 if(!isWasmInitialized) {
25819 throw new Error("initializeWasm() must be awaited first!");
25821 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone(orig);
25822 return nativeResponseValue;
25824 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
25826 export function COption_PathFailureZ_some(o: bigint): bigint {
25827 if(!isWasmInitialized) {
25828 throw new Error("initializeWasm() must be awaited first!");
25830 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
25831 return nativeResponseValue;
25833 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
25835 export function COption_PathFailureZ_none(): bigint {
25836 if(!isWasmInitialized) {
25837 throw new Error("initializeWasm() must be awaited first!");
25839 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
25840 return nativeResponseValue;
25842 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
25844 export function COption_PathFailureZ_free(_res: bigint): void {
25845 if(!isWasmInitialized) {
25846 throw new Error("initializeWasm() must be awaited first!");
25848 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
25849 // debug statements here
25851 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
25853 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
25854 if(!isWasmInitialized) {
25855 throw new Error("initializeWasm() must be awaited first!");
25857 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
25858 return nativeResponseValue;
25860 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
25862 export function COption_PathFailureZ_clone(orig: bigint): bigint {
25863 if(!isWasmInitialized) {
25864 throw new Error("initializeWasm() must be awaited first!");
25866 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
25867 return nativeResponseValue;
25869 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
25871 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
25872 if(!isWasmInitialized) {
25873 throw new Error("initializeWasm() must be awaited first!");
25875 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
25876 return nativeResponseValue;
25878 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
25880 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
25881 if(!isWasmInitialized) {
25882 throw new Error("initializeWasm() must be awaited first!");
25884 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
25885 return nativeResponseValue;
25887 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
25889 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
25890 if(!isWasmInitialized) {
25891 throw new Error("initializeWasm() must be awaited first!");
25893 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
25894 return nativeResponseValue;
25896 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
25898 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
25899 if(!isWasmInitialized) {
25900 throw new Error("initializeWasm() must be awaited first!");
25902 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
25903 // debug statements here
25905 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
25907 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25908 if(!isWasmInitialized) {
25909 throw new Error("initializeWasm() must be awaited first!");
25911 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
25912 return nativeResponseValue;
25914 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
25916 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
25917 if(!isWasmInitialized) {
25918 throw new Error("initializeWasm() must be awaited first!");
25920 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
25921 return nativeResponseValue;
25923 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
25925 export function COption_ClosureReasonZ_some(o: bigint): bigint {
25926 if(!isWasmInitialized) {
25927 throw new Error("initializeWasm() must be awaited first!");
25929 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
25930 return nativeResponseValue;
25932 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
25934 export function COption_ClosureReasonZ_none(): bigint {
25935 if(!isWasmInitialized) {
25936 throw new Error("initializeWasm() must be awaited first!");
25938 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
25939 return nativeResponseValue;
25941 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
25943 export function COption_ClosureReasonZ_free(_res: bigint): void {
25944 if(!isWasmInitialized) {
25945 throw new Error("initializeWasm() must be awaited first!");
25947 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
25948 // debug statements here
25950 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
25952 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
25953 if(!isWasmInitialized) {
25954 throw new Error("initializeWasm() must be awaited first!");
25956 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
25957 return nativeResponseValue;
25959 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
25961 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
25962 if(!isWasmInitialized) {
25963 throw new Error("initializeWasm() must be awaited first!");
25965 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
25966 return nativeResponseValue;
25968 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
25970 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
25971 if(!isWasmInitialized) {
25972 throw new Error("initializeWasm() must be awaited first!");
25974 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
25975 return nativeResponseValue;
25977 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
25979 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
25980 if(!isWasmInitialized) {
25981 throw new Error("initializeWasm() must be awaited first!");
25983 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
25984 return nativeResponseValue;
25986 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
25988 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
25989 if(!isWasmInitialized) {
25990 throw new Error("initializeWasm() must be awaited first!");
25992 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
25993 return nativeResponseValue;
25995 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
25997 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
25998 if(!isWasmInitialized) {
25999 throw new Error("initializeWasm() must be awaited first!");
26001 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
26002 // debug statements here
26004 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
26006 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26007 if(!isWasmInitialized) {
26008 throw new Error("initializeWasm() must be awaited first!");
26010 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
26011 return nativeResponseValue;
26013 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
26015 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
26016 if(!isWasmInitialized) {
26017 throw new Error("initializeWasm() must be awaited first!");
26019 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
26020 return nativeResponseValue;
26022 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
26024 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
26025 if(!isWasmInitialized) {
26026 throw new Error("initializeWasm() must be awaited first!");
26028 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
26029 return nativeResponseValue;
26031 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
26033 export function COption_HTLCDestinationZ_none(): bigint {
26034 if(!isWasmInitialized) {
26035 throw new Error("initializeWasm() must be awaited first!");
26037 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
26038 return nativeResponseValue;
26040 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
26042 export function COption_HTLCDestinationZ_free(_res: bigint): void {
26043 if(!isWasmInitialized) {
26044 throw new Error("initializeWasm() must be awaited first!");
26046 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
26047 // debug statements here
26049 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
26051 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
26052 if(!isWasmInitialized) {
26053 throw new Error("initializeWasm() must be awaited first!");
26055 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
26056 return nativeResponseValue;
26058 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
26060 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
26061 if(!isWasmInitialized) {
26062 throw new Error("initializeWasm() must be awaited first!");
26064 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
26065 return nativeResponseValue;
26067 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
26069 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
26070 if(!isWasmInitialized) {
26071 throw new Error("initializeWasm() must be awaited first!");
26073 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
26074 return nativeResponseValue;
26076 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
26078 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
26079 if(!isWasmInitialized) {
26080 throw new Error("initializeWasm() must be awaited first!");
26082 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
26083 return nativeResponseValue;
26085 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
26087 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
26088 if(!isWasmInitialized) {
26089 throw new Error("initializeWasm() must be awaited first!");
26091 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
26092 return nativeResponseValue;
26094 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
26096 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
26097 if(!isWasmInitialized) {
26098 throw new Error("initializeWasm() must be awaited first!");
26100 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
26101 // debug statements here
26103 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
26105 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26106 if(!isWasmInitialized) {
26107 throw new Error("initializeWasm() must be awaited first!");
26109 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
26110 return nativeResponseValue;
26112 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
26114 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
26115 if(!isWasmInitialized) {
26116 throw new Error("initializeWasm() must be awaited first!");
26118 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
26119 return nativeResponseValue;
26121 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
26123 export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
26124 if(!isWasmInitialized) {
26125 throw new Error("initializeWasm() must be awaited first!");
26127 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
26128 return nativeResponseValue;
26130 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
26132 export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
26133 if(!isWasmInitialized) {
26134 throw new Error("initializeWasm() must be awaited first!");
26136 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
26137 return nativeResponseValue;
26139 // bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
26141 export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
26142 if(!isWasmInitialized) {
26143 throw new Error("initializeWasm() must be awaited first!");
26145 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
26146 return nativeResponseValue;
26148 // void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
26150 export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
26151 if(!isWasmInitialized) {
26152 throw new Error("initializeWasm() must be awaited first!");
26154 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
26155 // debug statements here
26157 // uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
26159 export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26160 if(!isWasmInitialized) {
26161 throw new Error("initializeWasm() must be awaited first!");
26163 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
26164 return nativeResponseValue;
26166 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
26168 export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
26169 if(!isWasmInitialized) {
26170 throw new Error("initializeWasm() must be awaited first!");
26172 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
26173 return nativeResponseValue;
26175 // struct LDKCOption_U128Z COption_U128Z_some(struct LDKU128 o);
26177 export function COption_U128Z_some(o: number): bigint {
26178 if(!isWasmInitialized) {
26179 throw new Error("initializeWasm() must be awaited first!");
26181 const nativeResponseValue = wasm.TS_COption_U128Z_some(o);
26182 return nativeResponseValue;
26184 // struct LDKCOption_U128Z COption_U128Z_none(void);
26186 export function COption_U128Z_none(): bigint {
26187 if(!isWasmInitialized) {
26188 throw new Error("initializeWasm() must be awaited first!");
26190 const nativeResponseValue = wasm.TS_COption_U128Z_none();
26191 return nativeResponseValue;
26193 // void COption_U128Z_free(struct LDKCOption_U128Z _res);
26195 export function COption_U128Z_free(_res: bigint): void {
26196 if(!isWasmInitialized) {
26197 throw new Error("initializeWasm() must be awaited first!");
26199 const nativeResponseValue = wasm.TS_COption_U128Z_free(_res);
26200 // debug statements here
26202 // uint64_t COption_U128Z_clone_ptr(LDKCOption_U128Z *NONNULL_PTR arg);
26204 export function COption_U128Z_clone_ptr(arg: bigint): bigint {
26205 if(!isWasmInitialized) {
26206 throw new Error("initializeWasm() must be awaited first!");
26208 const nativeResponseValue = wasm.TS_COption_U128Z_clone_ptr(arg);
26209 return nativeResponseValue;
26211 // struct LDKCOption_U128Z COption_U128Z_clone(const struct LDKCOption_U128Z *NONNULL_PTR orig);
26213 export function COption_U128Z_clone(orig: bigint): bigint {
26214 if(!isWasmInitialized) {
26215 throw new Error("initializeWasm() must be awaited first!");
26217 const nativeResponseValue = wasm.TS_COption_U128Z_clone(orig);
26218 return nativeResponseValue;
26220 // void CVec_ClaimedHTLCZ_free(struct LDKCVec_ClaimedHTLCZ _res);
26222 export function CVec_ClaimedHTLCZ_free(_res: number): void {
26223 if(!isWasmInitialized) {
26224 throw new Error("initializeWasm() must be awaited first!");
26226 const nativeResponseValue = wasm.TS_CVec_ClaimedHTLCZ_free(_res);
26227 // debug statements here
26229 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
26231 export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
26232 if(!isWasmInitialized) {
26233 throw new Error("initializeWasm() must be awaited first!");
26235 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
26236 return nativeResponseValue;
26238 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
26240 export function COption_PaymentFailureReasonZ_none(): bigint {
26241 if(!isWasmInitialized) {
26242 throw new Error("initializeWasm() must be awaited first!");
26244 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
26245 return nativeResponseValue;
26247 // void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
26249 export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
26250 if(!isWasmInitialized) {
26251 throw new Error("initializeWasm() must be awaited first!");
26253 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
26254 // debug statements here
26256 // uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
26258 export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
26259 if(!isWasmInitialized) {
26260 throw new Error("initializeWasm() must be awaited first!");
26262 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
26263 return nativeResponseValue;
26265 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
26267 export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
26268 if(!isWasmInitialized) {
26269 throw new Error("initializeWasm() must be awaited first!");
26271 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
26272 return nativeResponseValue;
26274 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
26276 export function COption_EventZ_some(o: bigint): bigint {
26277 if(!isWasmInitialized) {
26278 throw new Error("initializeWasm() must be awaited first!");
26280 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
26281 return nativeResponseValue;
26283 // struct LDKCOption_EventZ COption_EventZ_none(void);
26285 export function COption_EventZ_none(): bigint {
26286 if(!isWasmInitialized) {
26287 throw new Error("initializeWasm() must be awaited first!");
26289 const nativeResponseValue = wasm.TS_COption_EventZ_none();
26290 return nativeResponseValue;
26292 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
26294 export function COption_EventZ_free(_res: bigint): void {
26295 if(!isWasmInitialized) {
26296 throw new Error("initializeWasm() must be awaited first!");
26298 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
26299 // debug statements here
26301 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
26303 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
26304 if(!isWasmInitialized) {
26305 throw new Error("initializeWasm() must be awaited first!");
26307 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
26308 return nativeResponseValue;
26310 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
26312 export function COption_EventZ_clone(orig: bigint): bigint {
26313 if(!isWasmInitialized) {
26314 throw new Error("initializeWasm() must be awaited first!");
26316 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
26317 return nativeResponseValue;
26319 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
26321 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
26322 if(!isWasmInitialized) {
26323 throw new Error("initializeWasm() must be awaited first!");
26325 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
26326 return nativeResponseValue;
26328 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
26330 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
26331 if(!isWasmInitialized) {
26332 throw new Error("initializeWasm() must be awaited first!");
26334 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
26335 return nativeResponseValue;
26337 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
26339 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
26340 if(!isWasmInitialized) {
26341 throw new Error("initializeWasm() must be awaited first!");
26343 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
26344 return nativeResponseValue;
26346 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
26348 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
26349 if(!isWasmInitialized) {
26350 throw new Error("initializeWasm() must be awaited first!");
26352 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
26353 // debug statements here
26355 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
26357 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26358 if(!isWasmInitialized) {
26359 throw new Error("initializeWasm() must be awaited first!");
26361 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
26362 return nativeResponseValue;
26364 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
26366 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
26367 if(!isWasmInitialized) {
26368 throw new Error("initializeWasm() must be awaited first!");
26370 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
26371 return nativeResponseValue;
26373 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_ok(enum LDKSiPrefix o);
26375 export function CResult_SiPrefixBolt11ParseErrorZ_ok(o: SiPrefix): bigint {
26376 if(!isWasmInitialized) {
26377 throw new Error("initializeWasm() must be awaited first!");
26379 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_ok(o);
26380 return nativeResponseValue;
26382 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
26384 export function CResult_SiPrefixBolt11ParseErrorZ_err(e: bigint): bigint {
26385 if(!isWasmInitialized) {
26386 throw new Error("initializeWasm() must be awaited first!");
26388 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_err(e);
26389 return nativeResponseValue;
26391 // bool CResult_SiPrefixBolt11ParseErrorZ_is_ok(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR o);
26393 export function CResult_SiPrefixBolt11ParseErrorZ_is_ok(o: bigint): boolean {
26394 if(!isWasmInitialized) {
26395 throw new Error("initializeWasm() must be awaited first!");
26397 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(o);
26398 return nativeResponseValue;
26400 // void CResult_SiPrefixBolt11ParseErrorZ_free(struct LDKCResult_SiPrefixBolt11ParseErrorZ _res);
26402 export function CResult_SiPrefixBolt11ParseErrorZ_free(_res: bigint): void {
26403 if(!isWasmInitialized) {
26404 throw new Error("initializeWasm() must be awaited first!");
26406 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_free(_res);
26407 // debug statements here
26409 // uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg);
26411 export function CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
26412 if(!isWasmInitialized) {
26413 throw new Error("initializeWasm() must be awaited first!");
26415 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg);
26416 return nativeResponseValue;
26418 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_clone(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR orig);
26420 export function CResult_SiPrefixBolt11ParseErrorZ_clone(orig: bigint): bigint {
26421 if(!isWasmInitialized) {
26422 throw new Error("initializeWasm() must be awaited first!");
26424 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone(orig);
26425 return nativeResponseValue;
26427 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(struct LDKBolt11Invoice o);
26429 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
26430 if(!isWasmInitialized) {
26431 throw new Error("initializeWasm() must be awaited first!");
26433 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o);
26434 return nativeResponseValue;
26436 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
26438 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
26439 if(!isWasmInitialized) {
26440 throw new Error("initializeWasm() must be awaited first!");
26442 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e);
26443 return nativeResponseValue;
26445 // bool CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
26447 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
26448 if(!isWasmInitialized) {
26449 throw new Error("initializeWasm() must be awaited first!");
26451 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o);
26452 return nativeResponseValue;
26454 // void CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res);
26456 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
26457 if(!isWasmInitialized) {
26458 throw new Error("initializeWasm() must be awaited first!");
26460 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res);
26461 // debug statements here
26463 // uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
26465 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
26466 if(!isWasmInitialized) {
26467 throw new Error("initializeWasm() must be awaited first!");
26469 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
26470 return nativeResponseValue;
26472 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
26474 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
26475 if(!isWasmInitialized) {
26476 throw new Error("initializeWasm() must be awaited first!");
26478 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig);
26479 return nativeResponseValue;
26481 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(struct LDKSignedRawBolt11Invoice o);
26483 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o: bigint): bigint {
26484 if(!isWasmInitialized) {
26485 throw new Error("initializeWasm() must be awaited first!");
26487 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o);
26488 return nativeResponseValue;
26490 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
26492 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e: bigint): bigint {
26493 if(!isWasmInitialized) {
26494 throw new Error("initializeWasm() must be awaited first!");
26496 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e);
26497 return nativeResponseValue;
26499 // bool CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR o);
26501 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o: bigint): boolean {
26502 if(!isWasmInitialized) {
26503 throw new Error("initializeWasm() must be awaited first!");
26505 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o);
26506 return nativeResponseValue;
26508 // void CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res);
26510 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res: bigint): void {
26511 if(!isWasmInitialized) {
26512 throw new Error("initializeWasm() must be awaited first!");
26514 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res);
26515 // debug statements here
26517 // uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg);
26519 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
26520 if(!isWasmInitialized) {
26521 throw new Error("initializeWasm() must be awaited first!");
26523 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg);
26524 return nativeResponseValue;
26526 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR orig);
26528 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig: bigint): bigint {
26529 if(!isWasmInitialized) {
26530 throw new Error("initializeWasm() must be awaited first!");
26532 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig);
26533 return nativeResponseValue;
26535 // uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg);
26537 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
26538 if(!isWasmInitialized) {
26539 throw new Error("initializeWasm() must be awaited first!");
26541 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg);
26542 return nativeResponseValue;
26544 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR orig);
26546 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig: bigint): bigint {
26547 if(!isWasmInitialized) {
26548 throw new Error("initializeWasm() must be awaited first!");
26550 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig);
26551 return nativeResponseValue;
26553 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(struct LDKRawBolt11Invoice a, struct LDKThirtyTwoBytes b, struct LDKBolt11InvoiceSignature c);
26555 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
26556 if(!isWasmInitialized) {
26557 throw new Error("initializeWasm() must be awaited first!");
26559 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a, b, c);
26560 return nativeResponseValue;
26562 // void C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res);
26564 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res: bigint): void {
26565 if(!isWasmInitialized) {
26566 throw new Error("initializeWasm() must be awaited first!");
26568 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res);
26569 // debug statements here
26571 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_ok(struct LDKPayeePubKey o);
26573 export function CResult_PayeePubKeySecp256k1ErrorZ_ok(o: bigint): bigint {
26574 if(!isWasmInitialized) {
26575 throw new Error("initializeWasm() must be awaited first!");
26577 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_ok(o);
26578 return nativeResponseValue;
26580 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
26582 export function CResult_PayeePubKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
26583 if(!isWasmInitialized) {
26584 throw new Error("initializeWasm() must be awaited first!");
26586 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_err(e);
26587 return nativeResponseValue;
26589 // bool CResult_PayeePubKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR o);
26591 export function CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
26592 if(!isWasmInitialized) {
26593 throw new Error("initializeWasm() must be awaited first!");
26595 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o);
26596 return nativeResponseValue;
26598 // void CResult_PayeePubKeySecp256k1ErrorZ_free(struct LDKCResult_PayeePubKeySecp256k1ErrorZ _res);
26600 export function CResult_PayeePubKeySecp256k1ErrorZ_free(_res: bigint): void {
26601 if(!isWasmInitialized) {
26602 throw new Error("initializeWasm() must be awaited first!");
26604 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_free(_res);
26605 // debug statements here
26607 // uint64_t CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR arg);
26609 export function CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
26610 if(!isWasmInitialized) {
26611 throw new Error("initializeWasm() must be awaited first!");
26613 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg);
26614 return nativeResponseValue;
26616 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_clone(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR orig);
26618 export function CResult_PayeePubKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
26619 if(!isWasmInitialized) {
26620 throw new Error("initializeWasm() must be awaited first!");
26622 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone(orig);
26623 return nativeResponseValue;
26625 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
26627 export function CVec_PrivateRouteZ_free(_res: number): void {
26628 if(!isWasmInitialized) {
26629 throw new Error("initializeWasm() must be awaited first!");
26631 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
26632 // debug statements here
26634 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
26636 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
26637 if(!isWasmInitialized) {
26638 throw new Error("initializeWasm() must be awaited first!");
26640 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
26641 return nativeResponseValue;
26643 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
26645 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
26646 if(!isWasmInitialized) {
26647 throw new Error("initializeWasm() must be awaited first!");
26649 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
26650 return nativeResponseValue;
26652 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
26654 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
26655 if(!isWasmInitialized) {
26656 throw new Error("initializeWasm() must be awaited first!");
26658 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
26659 return nativeResponseValue;
26661 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
26663 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
26664 if(!isWasmInitialized) {
26665 throw new Error("initializeWasm() must be awaited first!");
26667 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
26668 // debug statements here
26670 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
26672 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
26673 if(!isWasmInitialized) {
26674 throw new Error("initializeWasm() must be awaited first!");
26676 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
26677 return nativeResponseValue;
26679 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
26681 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
26682 if(!isWasmInitialized) {
26683 throw new Error("initializeWasm() must be awaited first!");
26685 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
26686 return nativeResponseValue;
26688 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_ok(void);
26690 export function CResult_NoneBolt11SemanticErrorZ_ok(): bigint {
26691 if(!isWasmInitialized) {
26692 throw new Error("initializeWasm() must be awaited first!");
26694 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_ok();
26695 return nativeResponseValue;
26697 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
26699 export function CResult_NoneBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
26700 if(!isWasmInitialized) {
26701 throw new Error("initializeWasm() must be awaited first!");
26703 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_err(e);
26704 return nativeResponseValue;
26706 // bool CResult_NoneBolt11SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR o);
26708 export function CResult_NoneBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
26709 if(!isWasmInitialized) {
26710 throw new Error("initializeWasm() must be awaited first!");
26712 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_is_ok(o);
26713 return nativeResponseValue;
26715 // void CResult_NoneBolt11SemanticErrorZ_free(struct LDKCResult_NoneBolt11SemanticErrorZ _res);
26717 export function CResult_NoneBolt11SemanticErrorZ_free(_res: bigint): void {
26718 if(!isWasmInitialized) {
26719 throw new Error("initializeWasm() must be awaited first!");
26721 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_free(_res);
26722 // debug statements here
26724 // uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg);
26726 export function CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
26727 if(!isWasmInitialized) {
26728 throw new Error("initializeWasm() must be awaited first!");
26730 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg);
26731 return nativeResponseValue;
26733 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_clone(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR orig);
26735 export function CResult_NoneBolt11SemanticErrorZ_clone(orig: bigint): bigint {
26736 if(!isWasmInitialized) {
26737 throw new Error("initializeWasm() must be awaited first!");
26739 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone(orig);
26740 return nativeResponseValue;
26742 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(struct LDKBolt11Invoice o);
26744 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o: bigint): bigint {
26745 if(!isWasmInitialized) {
26746 throw new Error("initializeWasm() must be awaited first!");
26748 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o);
26749 return nativeResponseValue;
26751 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
26753 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
26754 if(!isWasmInitialized) {
26755 throw new Error("initializeWasm() must be awaited first!");
26757 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e);
26758 return nativeResponseValue;
26760 // bool CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR o);
26762 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
26763 if(!isWasmInitialized) {
26764 throw new Error("initializeWasm() must be awaited first!");
26766 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o);
26767 return nativeResponseValue;
26769 // void CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res);
26771 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res: bigint): void {
26772 if(!isWasmInitialized) {
26773 throw new Error("initializeWasm() must be awaited first!");
26775 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res);
26776 // debug statements here
26778 // uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg);
26780 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
26781 if(!isWasmInitialized) {
26782 throw new Error("initializeWasm() must be awaited first!");
26784 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg);
26785 return nativeResponseValue;
26787 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR orig);
26789 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig: bigint): bigint {
26790 if(!isWasmInitialized) {
26791 throw new Error("initializeWasm() must be awaited first!");
26793 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig);
26794 return nativeResponseValue;
26796 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
26798 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
26799 if(!isWasmInitialized) {
26800 throw new Error("initializeWasm() must be awaited first!");
26802 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
26803 return nativeResponseValue;
26805 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
26807 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
26808 if(!isWasmInitialized) {
26809 throw new Error("initializeWasm() must be awaited first!");
26811 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
26812 return nativeResponseValue;
26814 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
26816 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
26817 if(!isWasmInitialized) {
26818 throw new Error("initializeWasm() must be awaited first!");
26820 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
26821 return nativeResponseValue;
26823 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
26825 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
26826 if(!isWasmInitialized) {
26827 throw new Error("initializeWasm() must be awaited first!");
26829 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
26830 // debug statements here
26832 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
26834 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
26835 if(!isWasmInitialized) {
26836 throw new Error("initializeWasm() must be awaited first!");
26838 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
26839 return nativeResponseValue;
26841 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
26843 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
26844 if(!isWasmInitialized) {
26845 throw new Error("initializeWasm() must be awaited first!");
26847 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
26848 return nativeResponseValue;
26850 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
26852 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
26853 if(!isWasmInitialized) {
26854 throw new Error("initializeWasm() must be awaited first!");
26856 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
26857 return nativeResponseValue;
26859 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
26861 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
26862 if(!isWasmInitialized) {
26863 throw new Error("initializeWasm() must be awaited first!");
26865 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
26866 return nativeResponseValue;
26868 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
26870 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
26871 if(!isWasmInitialized) {
26872 throw new Error("initializeWasm() must be awaited first!");
26874 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
26875 return nativeResponseValue;
26877 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
26879 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
26880 if(!isWasmInitialized) {
26881 throw new Error("initializeWasm() must be awaited first!");
26883 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
26884 // debug statements here
26886 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
26888 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
26889 if(!isWasmInitialized) {
26890 throw new Error("initializeWasm() must be awaited first!");
26892 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
26893 return nativeResponseValue;
26895 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
26897 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
26898 if(!isWasmInitialized) {
26899 throw new Error("initializeWasm() must be awaited first!");
26901 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
26902 return nativeResponseValue;
26904 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
26906 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
26907 if(!isWasmInitialized) {
26908 throw new Error("initializeWasm() must be awaited first!");
26910 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
26911 return nativeResponseValue;
26913 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
26915 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
26916 if(!isWasmInitialized) {
26917 throw new Error("initializeWasm() must be awaited first!");
26919 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
26920 return nativeResponseValue;
26922 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
26924 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
26925 if(!isWasmInitialized) {
26926 throw new Error("initializeWasm() must be awaited first!");
26928 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
26929 return nativeResponseValue;
26931 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
26933 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
26934 if(!isWasmInitialized) {
26935 throw new Error("initializeWasm() must be awaited first!");
26937 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
26938 // debug statements here
26940 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
26942 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26943 if(!isWasmInitialized) {
26944 throw new Error("initializeWasm() must be awaited first!");
26946 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
26947 return nativeResponseValue;
26949 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
26951 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
26952 if(!isWasmInitialized) {
26953 throw new Error("initializeWasm() must be awaited first!");
26955 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
26956 return nativeResponseValue;
26958 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_ok(struct LDKBigSize o);
26960 export function CResult_BigSizeDecodeErrorZ_ok(o: bigint): bigint {
26961 if(!isWasmInitialized) {
26962 throw new Error("initializeWasm() must be awaited first!");
26964 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_ok(o);
26965 return nativeResponseValue;
26967 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_err(struct LDKDecodeError e);
26969 export function CResult_BigSizeDecodeErrorZ_err(e: bigint): bigint {
26970 if(!isWasmInitialized) {
26971 throw new Error("initializeWasm() must be awaited first!");
26973 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_err(e);
26974 return nativeResponseValue;
26976 // bool CResult_BigSizeDecodeErrorZ_is_ok(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR o);
26978 export function CResult_BigSizeDecodeErrorZ_is_ok(o: bigint): boolean {
26979 if(!isWasmInitialized) {
26980 throw new Error("initializeWasm() must be awaited first!");
26982 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_is_ok(o);
26983 return nativeResponseValue;
26985 // void CResult_BigSizeDecodeErrorZ_free(struct LDKCResult_BigSizeDecodeErrorZ _res);
26987 export function CResult_BigSizeDecodeErrorZ_free(_res: bigint): void {
26988 if(!isWasmInitialized) {
26989 throw new Error("initializeWasm() must be awaited first!");
26991 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_free(_res);
26992 // debug statements here
26994 // uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg);
26996 export function CResult_BigSizeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26997 if(!isWasmInitialized) {
26998 throw new Error("initializeWasm() must be awaited first!");
27000 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone_ptr(arg);
27001 return nativeResponseValue;
27003 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_clone(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR orig);
27005 export function CResult_BigSizeDecodeErrorZ_clone(orig: bigint): bigint {
27006 if(!isWasmInitialized) {
27007 throw new Error("initializeWasm() must be awaited first!");
27009 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone(orig);
27010 return nativeResponseValue;
27012 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_ok(struct LDKHostname o);
27014 export function CResult_HostnameDecodeErrorZ_ok(o: bigint): bigint {
27015 if(!isWasmInitialized) {
27016 throw new Error("initializeWasm() must be awaited first!");
27018 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_ok(o);
27019 return nativeResponseValue;
27021 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_err(struct LDKDecodeError e);
27023 export function CResult_HostnameDecodeErrorZ_err(e: bigint): bigint {
27024 if(!isWasmInitialized) {
27025 throw new Error("initializeWasm() must be awaited first!");
27027 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_err(e);
27028 return nativeResponseValue;
27030 // bool CResult_HostnameDecodeErrorZ_is_ok(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR o);
27032 export function CResult_HostnameDecodeErrorZ_is_ok(o: bigint): boolean {
27033 if(!isWasmInitialized) {
27034 throw new Error("initializeWasm() must be awaited first!");
27036 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_is_ok(o);
27037 return nativeResponseValue;
27039 // void CResult_HostnameDecodeErrorZ_free(struct LDKCResult_HostnameDecodeErrorZ _res);
27041 export function CResult_HostnameDecodeErrorZ_free(_res: bigint): void {
27042 if(!isWasmInitialized) {
27043 throw new Error("initializeWasm() must be awaited first!");
27045 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_free(_res);
27046 // debug statements here
27048 // uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg);
27050 export function CResult_HostnameDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27051 if(!isWasmInitialized) {
27052 throw new Error("initializeWasm() must be awaited first!");
27054 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone_ptr(arg);
27055 return nativeResponseValue;
27057 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_clone(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR orig);
27059 export function CResult_HostnameDecodeErrorZ_clone(orig: bigint): bigint {
27060 if(!isWasmInitialized) {
27061 throw new Error("initializeWasm() must be awaited first!");
27063 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone(orig);
27064 return nativeResponseValue;
27066 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_ok(struct LDKTransactionU16LenLimited o);
27068 export function CResult_TransactionU16LenLimitedNoneZ_ok(o: bigint): bigint {
27069 if(!isWasmInitialized) {
27070 throw new Error("initializeWasm() must be awaited first!");
27072 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_ok(o);
27073 return nativeResponseValue;
27075 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_err(void);
27077 export function CResult_TransactionU16LenLimitedNoneZ_err(): bigint {
27078 if(!isWasmInitialized) {
27079 throw new Error("initializeWasm() must be awaited first!");
27081 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_err();
27082 return nativeResponseValue;
27084 // bool CResult_TransactionU16LenLimitedNoneZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR o);
27086 export function CResult_TransactionU16LenLimitedNoneZ_is_ok(o: bigint): boolean {
27087 if(!isWasmInitialized) {
27088 throw new Error("initializeWasm() must be awaited first!");
27090 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(o);
27091 return nativeResponseValue;
27093 // void CResult_TransactionU16LenLimitedNoneZ_free(struct LDKCResult_TransactionU16LenLimitedNoneZ _res);
27095 export function CResult_TransactionU16LenLimitedNoneZ_free(_res: bigint): void {
27096 if(!isWasmInitialized) {
27097 throw new Error("initializeWasm() must be awaited first!");
27099 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_free(_res);
27100 // debug statements here
27102 // uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg);
27104 export function CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg: bigint): bigint {
27105 if(!isWasmInitialized) {
27106 throw new Error("initializeWasm() must be awaited first!");
27108 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg);
27109 return nativeResponseValue;
27111 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_clone(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR orig);
27113 export function CResult_TransactionU16LenLimitedNoneZ_clone(orig: bigint): bigint {
27114 if(!isWasmInitialized) {
27115 throw new Error("initializeWasm() must be awaited first!");
27117 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone(orig);
27118 return nativeResponseValue;
27120 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_ok(struct LDKTransactionU16LenLimited o);
27122 export function CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o: bigint): bigint {
27123 if(!isWasmInitialized) {
27124 throw new Error("initializeWasm() must be awaited first!");
27126 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o);
27127 return nativeResponseValue;
27129 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_err(struct LDKDecodeError e);
27131 export function CResult_TransactionU16LenLimitedDecodeErrorZ_err(e: bigint): bigint {
27132 if(!isWasmInitialized) {
27133 throw new Error("initializeWasm() must be awaited first!");
27135 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(e);
27136 return nativeResponseValue;
27138 // bool CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR o);
27140 export function CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o: bigint): boolean {
27141 if(!isWasmInitialized) {
27142 throw new Error("initializeWasm() must be awaited first!");
27144 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o);
27145 return nativeResponseValue;
27147 // void CResult_TransactionU16LenLimitedDecodeErrorZ_free(struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res);
27149 export function CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res: bigint): void {
27150 if(!isWasmInitialized) {
27151 throw new Error("initializeWasm() must be awaited first!");
27153 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res);
27154 // debug statements here
27156 // uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg);
27158 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27159 if(!isWasmInitialized) {
27160 throw new Error("initializeWasm() must be awaited first!");
27162 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg);
27163 return nativeResponseValue;
27165 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_clone(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR orig);
27167 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig: bigint): bigint {
27168 if(!isWasmInitialized) {
27169 throw new Error("initializeWasm() must be awaited first!");
27171 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig);
27172 return nativeResponseValue;
27174 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
27176 export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
27177 if(!isWasmInitialized) {
27178 throw new Error("initializeWasm() must be awaited first!");
27180 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
27181 return nativeResponseValue;
27183 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
27185 export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
27186 if(!isWasmInitialized) {
27187 throw new Error("initializeWasm() must be awaited first!");
27189 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
27190 return nativeResponseValue;
27192 // bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
27194 export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
27195 if(!isWasmInitialized) {
27196 throw new Error("initializeWasm() must be awaited first!");
27198 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
27199 return nativeResponseValue;
27201 // void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
27203 export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
27204 if(!isWasmInitialized) {
27205 throw new Error("initializeWasm() must be awaited first!");
27207 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
27208 // debug statements here
27210 // uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
27212 export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27213 if(!isWasmInitialized) {
27214 throw new Error("initializeWasm() must be awaited first!");
27216 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
27217 return nativeResponseValue;
27219 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
27221 export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
27222 if(!isWasmInitialized) {
27223 throw new Error("initializeWasm() must be awaited first!");
27225 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
27226 return nativeResponseValue;
27228 // struct LDKCResult_ChannelIdDecodeErrorZ CResult_ChannelIdDecodeErrorZ_ok(struct LDKChannelId o);
27230 export function CResult_ChannelIdDecodeErrorZ_ok(o: bigint): bigint {
27231 if(!isWasmInitialized) {
27232 throw new Error("initializeWasm() must be awaited first!");
27234 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_ok(o);
27235 return nativeResponseValue;
27237 // struct LDKCResult_ChannelIdDecodeErrorZ CResult_ChannelIdDecodeErrorZ_err(struct LDKDecodeError e);
27239 export function CResult_ChannelIdDecodeErrorZ_err(e: bigint): bigint {
27240 if(!isWasmInitialized) {
27241 throw new Error("initializeWasm() must be awaited first!");
27243 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_err(e);
27244 return nativeResponseValue;
27246 // bool CResult_ChannelIdDecodeErrorZ_is_ok(const struct LDKCResult_ChannelIdDecodeErrorZ *NONNULL_PTR o);
27248 export function CResult_ChannelIdDecodeErrorZ_is_ok(o: bigint): boolean {
27249 if(!isWasmInitialized) {
27250 throw new Error("initializeWasm() must be awaited first!");
27252 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_is_ok(o);
27253 return nativeResponseValue;
27255 // void CResult_ChannelIdDecodeErrorZ_free(struct LDKCResult_ChannelIdDecodeErrorZ _res);
27257 export function CResult_ChannelIdDecodeErrorZ_free(_res: bigint): void {
27258 if(!isWasmInitialized) {
27259 throw new Error("initializeWasm() must be awaited first!");
27261 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_free(_res);
27262 // debug statements here
27264 // uint64_t CResult_ChannelIdDecodeErrorZ_clone_ptr(LDKCResult_ChannelIdDecodeErrorZ *NONNULL_PTR arg);
27266 export function CResult_ChannelIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27267 if(!isWasmInitialized) {
27268 throw new Error("initializeWasm() must be awaited first!");
27270 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_clone_ptr(arg);
27271 return nativeResponseValue;
27273 // struct LDKCResult_ChannelIdDecodeErrorZ CResult_ChannelIdDecodeErrorZ_clone(const struct LDKCResult_ChannelIdDecodeErrorZ *NONNULL_PTR orig);
27275 export function CResult_ChannelIdDecodeErrorZ_clone(orig: bigint): bigint {
27276 if(!isWasmInitialized) {
27277 throw new Error("initializeWasm() must be awaited first!");
27279 const nativeResponseValue = wasm.TS_CResult_ChannelIdDecodeErrorZ_clone(orig);
27280 return nativeResponseValue;
27282 // uint64_t C2Tuple__u832u16Z_clone_ptr(LDKC2Tuple__u832u16Z *NONNULL_PTR arg);
27284 export function C2Tuple__u832u16Z_clone_ptr(arg: bigint): bigint {
27285 if(!isWasmInitialized) {
27286 throw new Error("initializeWasm() must be awaited first!");
27288 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_clone_ptr(arg);
27289 return nativeResponseValue;
27291 // struct LDKC2Tuple__u832u16Z C2Tuple__u832u16Z_clone(const struct LDKC2Tuple__u832u16Z *NONNULL_PTR orig);
27293 export function C2Tuple__u832u16Z_clone(orig: bigint): bigint {
27294 if(!isWasmInitialized) {
27295 throw new Error("initializeWasm() must be awaited first!");
27297 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_clone(orig);
27298 return nativeResponseValue;
27300 // struct LDKC2Tuple__u832u16Z C2Tuple__u832u16Z_new(struct LDKThirtyTwoBytes a, uint16_t b);
27302 export function C2Tuple__u832u16Z_new(a: number, b: number): bigint {
27303 if(!isWasmInitialized) {
27304 throw new Error("initializeWasm() must be awaited first!");
27306 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_new(a, b);
27307 return nativeResponseValue;
27309 // void C2Tuple__u832u16Z_free(struct LDKC2Tuple__u832u16Z _res);
27311 export function C2Tuple__u832u16Z_free(_res: bigint): void {
27312 if(!isWasmInitialized) {
27313 throw new Error("initializeWasm() must be awaited first!");
27315 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_free(_res);
27316 // debug statements here
27318 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_ok(struct LDKPaymentRelay o);
27320 export function CResult_PaymentRelayDecodeErrorZ_ok(o: bigint): bigint {
27321 if(!isWasmInitialized) {
27322 throw new Error("initializeWasm() must be awaited first!");
27324 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_ok(o);
27325 return nativeResponseValue;
27327 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_err(struct LDKDecodeError e);
27329 export function CResult_PaymentRelayDecodeErrorZ_err(e: bigint): bigint {
27330 if(!isWasmInitialized) {
27331 throw new Error("initializeWasm() must be awaited first!");
27333 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_err(e);
27334 return nativeResponseValue;
27336 // bool CResult_PaymentRelayDecodeErrorZ_is_ok(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR o);
27338 export function CResult_PaymentRelayDecodeErrorZ_is_ok(o: bigint): boolean {
27339 if(!isWasmInitialized) {
27340 throw new Error("initializeWasm() must be awaited first!");
27342 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_is_ok(o);
27343 return nativeResponseValue;
27345 // void CResult_PaymentRelayDecodeErrorZ_free(struct LDKCResult_PaymentRelayDecodeErrorZ _res);
27347 export function CResult_PaymentRelayDecodeErrorZ_free(_res: bigint): void {
27348 if(!isWasmInitialized) {
27349 throw new Error("initializeWasm() must be awaited first!");
27351 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_free(_res);
27352 // debug statements here
27354 // uint64_t CResult_PaymentRelayDecodeErrorZ_clone_ptr(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR arg);
27356 export function CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27357 if(!isWasmInitialized) {
27358 throw new Error("initializeWasm() must be awaited first!");
27360 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg);
27361 return nativeResponseValue;
27363 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_clone(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR orig);
27365 export function CResult_PaymentRelayDecodeErrorZ_clone(orig: bigint): bigint {
27366 if(!isWasmInitialized) {
27367 throw new Error("initializeWasm() must be awaited first!");
27369 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone(orig);
27370 return nativeResponseValue;
27372 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_ok(struct LDKPaymentConstraints o);
27374 export function CResult_PaymentConstraintsDecodeErrorZ_ok(o: bigint): bigint {
27375 if(!isWasmInitialized) {
27376 throw new Error("initializeWasm() must be awaited first!");
27378 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_ok(o);
27379 return nativeResponseValue;
27381 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_err(struct LDKDecodeError e);
27383 export function CResult_PaymentConstraintsDecodeErrorZ_err(e: bigint): bigint {
27384 if(!isWasmInitialized) {
27385 throw new Error("initializeWasm() must be awaited first!");
27387 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_err(e);
27388 return nativeResponseValue;
27390 // bool CResult_PaymentConstraintsDecodeErrorZ_is_ok(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR o);
27392 export function CResult_PaymentConstraintsDecodeErrorZ_is_ok(o: bigint): boolean {
27393 if(!isWasmInitialized) {
27394 throw new Error("initializeWasm() must be awaited first!");
27396 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok(o);
27397 return nativeResponseValue;
27399 // void CResult_PaymentConstraintsDecodeErrorZ_free(struct LDKCResult_PaymentConstraintsDecodeErrorZ _res);
27401 export function CResult_PaymentConstraintsDecodeErrorZ_free(_res: bigint): void {
27402 if(!isWasmInitialized) {
27403 throw new Error("initializeWasm() must be awaited first!");
27405 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_free(_res);
27406 // debug statements here
27408 // uint64_t CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR arg);
27410 export function CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27411 if(!isWasmInitialized) {
27412 throw new Error("initializeWasm() must be awaited first!");
27414 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg);
27415 return nativeResponseValue;
27417 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_clone(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR orig);
27419 export function CResult_PaymentConstraintsDecodeErrorZ_clone(orig: bigint): bigint {
27420 if(!isWasmInitialized) {
27421 throw new Error("initializeWasm() must be awaited first!");
27423 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone(orig);
27424 return nativeResponseValue;
27426 // struct LDKCResult_PaymentContextDecodeErrorZ CResult_PaymentContextDecodeErrorZ_ok(struct LDKPaymentContext o);
27428 export function CResult_PaymentContextDecodeErrorZ_ok(o: bigint): bigint {
27429 if(!isWasmInitialized) {
27430 throw new Error("initializeWasm() must be awaited first!");
27432 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_ok(o);
27433 return nativeResponseValue;
27435 // struct LDKCResult_PaymentContextDecodeErrorZ CResult_PaymentContextDecodeErrorZ_err(struct LDKDecodeError e);
27437 export function CResult_PaymentContextDecodeErrorZ_err(e: bigint): bigint {
27438 if(!isWasmInitialized) {
27439 throw new Error("initializeWasm() must be awaited first!");
27441 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_err(e);
27442 return nativeResponseValue;
27444 // bool CResult_PaymentContextDecodeErrorZ_is_ok(const struct LDKCResult_PaymentContextDecodeErrorZ *NONNULL_PTR o);
27446 export function CResult_PaymentContextDecodeErrorZ_is_ok(o: bigint): boolean {
27447 if(!isWasmInitialized) {
27448 throw new Error("initializeWasm() must be awaited first!");
27450 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_is_ok(o);
27451 return nativeResponseValue;
27453 // void CResult_PaymentContextDecodeErrorZ_free(struct LDKCResult_PaymentContextDecodeErrorZ _res);
27455 export function CResult_PaymentContextDecodeErrorZ_free(_res: bigint): void {
27456 if(!isWasmInitialized) {
27457 throw new Error("initializeWasm() must be awaited first!");
27459 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_free(_res);
27460 // debug statements here
27462 // uint64_t CResult_PaymentContextDecodeErrorZ_clone_ptr(LDKCResult_PaymentContextDecodeErrorZ *NONNULL_PTR arg);
27464 export function CResult_PaymentContextDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27465 if(!isWasmInitialized) {
27466 throw new Error("initializeWasm() must be awaited first!");
27468 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_clone_ptr(arg);
27469 return nativeResponseValue;
27471 // struct LDKCResult_PaymentContextDecodeErrorZ CResult_PaymentContextDecodeErrorZ_clone(const struct LDKCResult_PaymentContextDecodeErrorZ *NONNULL_PTR orig);
27473 export function CResult_PaymentContextDecodeErrorZ_clone(orig: bigint): bigint {
27474 if(!isWasmInitialized) {
27475 throw new Error("initializeWasm() must be awaited first!");
27477 const nativeResponseValue = wasm.TS_CResult_PaymentContextDecodeErrorZ_clone(orig);
27478 return nativeResponseValue;
27480 // struct LDKCResult_UnknownPaymentContextDecodeErrorZ CResult_UnknownPaymentContextDecodeErrorZ_ok(struct LDKUnknownPaymentContext o);
27482 export function CResult_UnknownPaymentContextDecodeErrorZ_ok(o: bigint): bigint {
27483 if(!isWasmInitialized) {
27484 throw new Error("initializeWasm() must be awaited first!");
27486 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_ok(o);
27487 return nativeResponseValue;
27489 // struct LDKCResult_UnknownPaymentContextDecodeErrorZ CResult_UnknownPaymentContextDecodeErrorZ_err(struct LDKDecodeError e);
27491 export function CResult_UnknownPaymentContextDecodeErrorZ_err(e: bigint): bigint {
27492 if(!isWasmInitialized) {
27493 throw new Error("initializeWasm() must be awaited first!");
27495 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_err(e);
27496 return nativeResponseValue;
27498 // bool CResult_UnknownPaymentContextDecodeErrorZ_is_ok(const struct LDKCResult_UnknownPaymentContextDecodeErrorZ *NONNULL_PTR o);
27500 export function CResult_UnknownPaymentContextDecodeErrorZ_is_ok(o: bigint): boolean {
27501 if(!isWasmInitialized) {
27502 throw new Error("initializeWasm() must be awaited first!");
27504 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_is_ok(o);
27505 return nativeResponseValue;
27507 // void CResult_UnknownPaymentContextDecodeErrorZ_free(struct LDKCResult_UnknownPaymentContextDecodeErrorZ _res);
27509 export function CResult_UnknownPaymentContextDecodeErrorZ_free(_res: bigint): void {
27510 if(!isWasmInitialized) {
27511 throw new Error("initializeWasm() must be awaited first!");
27513 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_free(_res);
27514 // debug statements here
27516 // uint64_t CResult_UnknownPaymentContextDecodeErrorZ_clone_ptr(LDKCResult_UnknownPaymentContextDecodeErrorZ *NONNULL_PTR arg);
27518 export function CResult_UnknownPaymentContextDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27519 if(!isWasmInitialized) {
27520 throw new Error("initializeWasm() must be awaited first!");
27522 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_clone_ptr(arg);
27523 return nativeResponseValue;
27525 // struct LDKCResult_UnknownPaymentContextDecodeErrorZ CResult_UnknownPaymentContextDecodeErrorZ_clone(const struct LDKCResult_UnknownPaymentContextDecodeErrorZ *NONNULL_PTR orig);
27527 export function CResult_UnknownPaymentContextDecodeErrorZ_clone(orig: bigint): bigint {
27528 if(!isWasmInitialized) {
27529 throw new Error("initializeWasm() must be awaited first!");
27531 const nativeResponseValue = wasm.TS_CResult_UnknownPaymentContextDecodeErrorZ_clone(orig);
27532 return nativeResponseValue;
27534 // struct LDKCResult_Bolt12OfferContextDecodeErrorZ CResult_Bolt12OfferContextDecodeErrorZ_ok(struct LDKBolt12OfferContext o);
27536 export function CResult_Bolt12OfferContextDecodeErrorZ_ok(o: bigint): bigint {
27537 if(!isWasmInitialized) {
27538 throw new Error("initializeWasm() must be awaited first!");
27540 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_ok(o);
27541 return nativeResponseValue;
27543 // struct LDKCResult_Bolt12OfferContextDecodeErrorZ CResult_Bolt12OfferContextDecodeErrorZ_err(struct LDKDecodeError e);
27545 export function CResult_Bolt12OfferContextDecodeErrorZ_err(e: bigint): bigint {
27546 if(!isWasmInitialized) {
27547 throw new Error("initializeWasm() must be awaited first!");
27549 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_err(e);
27550 return nativeResponseValue;
27552 // bool CResult_Bolt12OfferContextDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12OfferContextDecodeErrorZ *NONNULL_PTR o);
27554 export function CResult_Bolt12OfferContextDecodeErrorZ_is_ok(o: bigint): boolean {
27555 if(!isWasmInitialized) {
27556 throw new Error("initializeWasm() must be awaited first!");
27558 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_is_ok(o);
27559 return nativeResponseValue;
27561 // void CResult_Bolt12OfferContextDecodeErrorZ_free(struct LDKCResult_Bolt12OfferContextDecodeErrorZ _res);
27563 export function CResult_Bolt12OfferContextDecodeErrorZ_free(_res: bigint): void {
27564 if(!isWasmInitialized) {
27565 throw new Error("initializeWasm() must be awaited first!");
27567 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_free(_res);
27568 // debug statements here
27570 // uint64_t CResult_Bolt12OfferContextDecodeErrorZ_clone_ptr(LDKCResult_Bolt12OfferContextDecodeErrorZ *NONNULL_PTR arg);
27572 export function CResult_Bolt12OfferContextDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27573 if(!isWasmInitialized) {
27574 throw new Error("initializeWasm() must be awaited first!");
27576 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_clone_ptr(arg);
27577 return nativeResponseValue;
27579 // struct LDKCResult_Bolt12OfferContextDecodeErrorZ CResult_Bolt12OfferContextDecodeErrorZ_clone(const struct LDKCResult_Bolt12OfferContextDecodeErrorZ *NONNULL_PTR orig);
27581 export function CResult_Bolt12OfferContextDecodeErrorZ_clone(orig: bigint): bigint {
27582 if(!isWasmInitialized) {
27583 throw new Error("initializeWasm() must be awaited first!");
27585 const nativeResponseValue = wasm.TS_CResult_Bolt12OfferContextDecodeErrorZ_clone(orig);
27586 return nativeResponseValue;
27588 // struct LDKCResult_Bolt12RefundContextDecodeErrorZ CResult_Bolt12RefundContextDecodeErrorZ_ok(struct LDKBolt12RefundContext o);
27590 export function CResult_Bolt12RefundContextDecodeErrorZ_ok(o: bigint): bigint {
27591 if(!isWasmInitialized) {
27592 throw new Error("initializeWasm() must be awaited first!");
27594 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_ok(o);
27595 return nativeResponseValue;
27597 // struct LDKCResult_Bolt12RefundContextDecodeErrorZ CResult_Bolt12RefundContextDecodeErrorZ_err(struct LDKDecodeError e);
27599 export function CResult_Bolt12RefundContextDecodeErrorZ_err(e: bigint): bigint {
27600 if(!isWasmInitialized) {
27601 throw new Error("initializeWasm() must be awaited first!");
27603 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_err(e);
27604 return nativeResponseValue;
27606 // bool CResult_Bolt12RefundContextDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12RefundContextDecodeErrorZ *NONNULL_PTR o);
27608 export function CResult_Bolt12RefundContextDecodeErrorZ_is_ok(o: bigint): boolean {
27609 if(!isWasmInitialized) {
27610 throw new Error("initializeWasm() must be awaited first!");
27612 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_is_ok(o);
27613 return nativeResponseValue;
27615 // void CResult_Bolt12RefundContextDecodeErrorZ_free(struct LDKCResult_Bolt12RefundContextDecodeErrorZ _res);
27617 export function CResult_Bolt12RefundContextDecodeErrorZ_free(_res: bigint): void {
27618 if(!isWasmInitialized) {
27619 throw new Error("initializeWasm() must be awaited first!");
27621 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_free(_res);
27622 // debug statements here
27624 // uint64_t CResult_Bolt12RefundContextDecodeErrorZ_clone_ptr(LDKCResult_Bolt12RefundContextDecodeErrorZ *NONNULL_PTR arg);
27626 export function CResult_Bolt12RefundContextDecodeErrorZ_clone_ptr(arg: bigint): bigint {
27627 if(!isWasmInitialized) {
27628 throw new Error("initializeWasm() must be awaited first!");
27630 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_clone_ptr(arg);
27631 return nativeResponseValue;
27633 // struct LDKCResult_Bolt12RefundContextDecodeErrorZ CResult_Bolt12RefundContextDecodeErrorZ_clone(const struct LDKCResult_Bolt12RefundContextDecodeErrorZ *NONNULL_PTR orig);
27635 export function CResult_Bolt12RefundContextDecodeErrorZ_clone(orig: bigint): bigint {
27636 if(!isWasmInitialized) {
27637 throw new Error("initializeWasm() must be awaited first!");
27639 const nativeResponseValue = wasm.TS_CResult_Bolt12RefundContextDecodeErrorZ_clone(orig);
27640 return nativeResponseValue;
27642 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_ok(struct LDKStr o);
27644 export function CResult_StrSecp256k1ErrorZ_ok(o: number): bigint {
27645 if(!isWasmInitialized) {
27646 throw new Error("initializeWasm() must be awaited first!");
27648 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_ok(o);
27649 return nativeResponseValue;
27651 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
27653 export function CResult_StrSecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
27654 if(!isWasmInitialized) {
27655 throw new Error("initializeWasm() must be awaited first!");
27657 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_err(e);
27658 return nativeResponseValue;
27660 // bool CResult_StrSecp256k1ErrorZ_is_ok(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR o);
27662 export function CResult_StrSecp256k1ErrorZ_is_ok(o: bigint): boolean {
27663 if(!isWasmInitialized) {
27664 throw new Error("initializeWasm() must be awaited first!");
27666 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_is_ok(o);
27667 return nativeResponseValue;
27669 // void CResult_StrSecp256k1ErrorZ_free(struct LDKCResult_StrSecp256k1ErrorZ _res);
27671 export function CResult_StrSecp256k1ErrorZ_free(_res: bigint): void {
27672 if(!isWasmInitialized) {
27673 throw new Error("initializeWasm() must be awaited first!");
27675 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_free(_res);
27676 // debug statements here
27678 // uint64_t CResult_StrSecp256k1ErrorZ_clone_ptr(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR arg);
27680 export function CResult_StrSecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
27681 if(!isWasmInitialized) {
27682 throw new Error("initializeWasm() must be awaited first!");
27684 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone_ptr(arg);
27685 return nativeResponseValue;
27687 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_clone(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR orig);
27689 export function CResult_StrSecp256k1ErrorZ_clone(orig: bigint): bigint {
27690 if(!isWasmInitialized) {
27691 throw new Error("initializeWasm() must be awaited first!");
27693 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone(orig);
27694 return nativeResponseValue;
27696 // uint64_t C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR arg);
27698 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(arg: bigint): bigint {
27699 if(!isWasmInitialized) {
27700 throw new Error("initializeWasm() must be awaited first!");
27702 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(arg);
27703 return nativeResponseValue;
27705 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(const struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR orig);
27707 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(orig: bigint): bigint {
27708 if(!isWasmInitialized) {
27709 throw new Error("initializeWasm() must be awaited first!");
27711 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(orig);
27712 return nativeResponseValue;
27714 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(struct LDKThirtyTwoBytes a, struct LDKRecipientOnionFields b, struct LDKRouteParameters c);
27716 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(a: number, b: bigint, c: bigint): bigint {
27717 if(!isWasmInitialized) {
27718 throw new Error("initializeWasm() must be awaited first!");
27720 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(a, b, c);
27721 return nativeResponseValue;
27723 // void C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ _res);
27725 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(_res: bigint): void {
27726 if(!isWasmInitialized) {
27727 throw new Error("initializeWasm() must be awaited first!");
27729 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(_res);
27730 // debug statements here
27732 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ o);
27734 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(o: bigint): bigint {
27735 if(!isWasmInitialized) {
27736 throw new Error("initializeWasm() must be awaited first!");
27738 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(o);
27739 return nativeResponseValue;
27741 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err(void);
27743 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err(): bigint {
27744 if(!isWasmInitialized) {
27745 throw new Error("initializeWasm() must be awaited first!");
27747 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err();
27748 return nativeResponseValue;
27750 // bool CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(const struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR o);
27752 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(o: bigint): boolean {
27753 if(!isWasmInitialized) {
27754 throw new Error("initializeWasm() must be awaited first!");
27756 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(o);
27757 return nativeResponseValue;
27759 // void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ _res);
27761 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(_res: bigint): void {
27762 if(!isWasmInitialized) {
27763 throw new Error("initializeWasm() must be awaited first!");
27765 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(_res);
27766 // debug statements here
27768 // uint64_t CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR arg);
27770 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(arg: bigint): bigint {
27771 if(!isWasmInitialized) {
27772 throw new Error("initializeWasm() must be awaited first!");
27774 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(arg);
27775 return nativeResponseValue;
27777 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(const struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR orig);
27779 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(orig: bigint): bigint {
27780 if(!isWasmInitialized) {
27781 throw new Error("initializeWasm() must be awaited first!");
27783 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(orig);
27784 return nativeResponseValue;
27786 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
27788 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
27789 if(!isWasmInitialized) {
27790 throw new Error("initializeWasm() must be awaited first!");
27792 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
27793 return nativeResponseValue;
27795 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
27797 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
27798 if(!isWasmInitialized) {
27799 throw new Error("initializeWasm() must be awaited first!");
27801 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
27802 return nativeResponseValue;
27804 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
27806 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
27807 if(!isWasmInitialized) {
27808 throw new Error("initializeWasm() must be awaited first!");
27810 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
27811 return nativeResponseValue;
27813 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
27815 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
27816 if(!isWasmInitialized) {
27817 throw new Error("initializeWasm() must be awaited first!");
27819 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
27820 // debug statements here
27822 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
27824 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
27825 if(!isWasmInitialized) {
27826 throw new Error("initializeWasm() must be awaited first!");
27828 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
27829 return nativeResponseValue;
27831 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
27833 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
27834 if(!isWasmInitialized) {
27835 throw new Error("initializeWasm() must be awaited first!");
27837 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
27838 return nativeResponseValue;
27840 // uint64_t C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR arg);
27842 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(arg: bigint): bigint {
27843 if(!isWasmInitialized) {
27844 throw new Error("initializeWasm() must be awaited first!");
27846 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(arg);
27847 return nativeResponseValue;
27849 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(const struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR orig);
27851 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(orig: bigint): bigint {
27852 if(!isWasmInitialized) {
27853 throw new Error("initializeWasm() must be awaited first!");
27855 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(orig);
27856 return nativeResponseValue;
27858 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(struct LDKPublicKey a, struct LDKOnionMessage b, struct LDKCOption_CVec_SocketAddressZZ c);
27860 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(a: number, b: bigint, c: bigint): bigint {
27861 if(!isWasmInitialized) {
27862 throw new Error("initializeWasm() must be awaited first!");
27864 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(a, b, c);
27865 return nativeResponseValue;
27867 // void C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ _res);
27869 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(_res: bigint): void {
27870 if(!isWasmInitialized) {
27871 throw new Error("initializeWasm() must be awaited first!");
27873 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(_res);
27874 // debug statements here
27876 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ o);
27878 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(o: bigint): bigint {
27879 if(!isWasmInitialized) {
27880 throw new Error("initializeWasm() must be awaited first!");
27882 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(o);
27883 return nativeResponseValue;
27885 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(struct LDKSendError e);
27887 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(e: bigint): bigint {
27888 if(!isWasmInitialized) {
27889 throw new Error("initializeWasm() must be awaited first!");
27891 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(e);
27892 return nativeResponseValue;
27894 // bool CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(const struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR o);
27896 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(o: bigint): boolean {
27897 if(!isWasmInitialized) {
27898 throw new Error("initializeWasm() must be awaited first!");
27900 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(o);
27901 return nativeResponseValue;
27903 // void CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ _res);
27905 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(_res: bigint): void {
27906 if(!isWasmInitialized) {
27907 throw new Error("initializeWasm() must be awaited first!");
27909 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(_res);
27910 // debug statements here
27912 // uint64_t CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone_ptr(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR arg);
27914 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone_ptr(arg: bigint): bigint {
27915 if(!isWasmInitialized) {
27916 throw new Error("initializeWasm() must be awaited first!");
27918 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone_ptr(arg);
27919 return nativeResponseValue;
27921 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone(const struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR orig);
27923 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone(orig: bigint): bigint {
27924 if(!isWasmInitialized) {
27925 throw new Error("initializeWasm() must be awaited first!");
27927 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_clone(orig);
27928 return nativeResponseValue;
27930 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_ok(struct LDKPeeledOnion o);
27932 export function CResult_PeeledOnionNoneZ_ok(o: bigint): bigint {
27933 if(!isWasmInitialized) {
27934 throw new Error("initializeWasm() must be awaited first!");
27936 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_ok(o);
27937 return nativeResponseValue;
27939 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_err(void);
27941 export function CResult_PeeledOnionNoneZ_err(): bigint {
27942 if(!isWasmInitialized) {
27943 throw new Error("initializeWasm() must be awaited first!");
27945 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_err();
27946 return nativeResponseValue;
27948 // bool CResult_PeeledOnionNoneZ_is_ok(const struct LDKCResult_PeeledOnionNoneZ *NONNULL_PTR o);
27950 export function CResult_PeeledOnionNoneZ_is_ok(o: bigint): boolean {
27951 if(!isWasmInitialized) {
27952 throw new Error("initializeWasm() must be awaited first!");
27954 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_is_ok(o);
27955 return nativeResponseValue;
27957 // void CResult_PeeledOnionNoneZ_free(struct LDKCResult_PeeledOnionNoneZ _res);
27959 export function CResult_PeeledOnionNoneZ_free(_res: bigint): void {
27960 if(!isWasmInitialized) {
27961 throw new Error("initializeWasm() must be awaited first!");
27963 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_free(_res);
27964 // debug statements here
27966 // uint64_t CResult_PeeledOnionNoneZ_clone_ptr(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR arg);
27968 export function CResult_PeeledOnionNoneZ_clone_ptr(arg: bigint): bigint {
27969 if(!isWasmInitialized) {
27970 throw new Error("initializeWasm() must be awaited first!");
27972 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_clone_ptr(arg);
27973 return nativeResponseValue;
27975 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_clone(const struct LDKCResult_PeeledOnionNoneZ *NONNULL_PTR orig);
27977 export function CResult_PeeledOnionNoneZ_clone(orig: bigint): bigint {
27978 if(!isWasmInitialized) {
27979 throw new Error("initializeWasm() must be awaited first!");
27981 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_clone(orig);
27982 return nativeResponseValue;
27984 // struct LDKCResult_SendSuccessSendErrorZ CResult_SendSuccessSendErrorZ_ok(struct LDKSendSuccess o);
27986 export function CResult_SendSuccessSendErrorZ_ok(o: bigint): bigint {
27987 if(!isWasmInitialized) {
27988 throw new Error("initializeWasm() must be awaited first!");
27990 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_ok(o);
27991 return nativeResponseValue;
27993 // struct LDKCResult_SendSuccessSendErrorZ CResult_SendSuccessSendErrorZ_err(struct LDKSendError e);
27995 export function CResult_SendSuccessSendErrorZ_err(e: bigint): bigint {
27996 if(!isWasmInitialized) {
27997 throw new Error("initializeWasm() must be awaited first!");
27999 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_err(e);
28000 return nativeResponseValue;
28002 // bool CResult_SendSuccessSendErrorZ_is_ok(const struct LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR o);
28004 export function CResult_SendSuccessSendErrorZ_is_ok(o: bigint): boolean {
28005 if(!isWasmInitialized) {
28006 throw new Error("initializeWasm() must be awaited first!");
28008 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_is_ok(o);
28009 return nativeResponseValue;
28011 // void CResult_SendSuccessSendErrorZ_free(struct LDKCResult_SendSuccessSendErrorZ _res);
28013 export function CResult_SendSuccessSendErrorZ_free(_res: bigint): void {
28014 if(!isWasmInitialized) {
28015 throw new Error("initializeWasm() must be awaited first!");
28017 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_free(_res);
28018 // debug statements here
28020 // uint64_t CResult_SendSuccessSendErrorZ_clone_ptr(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR arg);
28022 export function CResult_SendSuccessSendErrorZ_clone_ptr(arg: bigint): bigint {
28023 if(!isWasmInitialized) {
28024 throw new Error("initializeWasm() must be awaited first!");
28026 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_clone_ptr(arg);
28027 return nativeResponseValue;
28029 // struct LDKCResult_SendSuccessSendErrorZ CResult_SendSuccessSendErrorZ_clone(const struct LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR orig);
28031 export function CResult_SendSuccessSendErrorZ_clone(orig: bigint): bigint {
28032 if(!isWasmInitialized) {
28033 throw new Error("initializeWasm() must be awaited first!");
28035 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_clone(orig);
28036 return nativeResponseValue;
28038 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
28040 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
28041 if(!isWasmInitialized) {
28042 throw new Error("initializeWasm() must be awaited first!");
28044 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
28045 return nativeResponseValue;
28047 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
28049 export function CResult_BlindedPathNoneZ_err(): bigint {
28050 if(!isWasmInitialized) {
28051 throw new Error("initializeWasm() must be awaited first!");
28053 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
28054 return nativeResponseValue;
28056 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
28058 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
28059 if(!isWasmInitialized) {
28060 throw new Error("initializeWasm() must be awaited first!");
28062 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
28063 return nativeResponseValue;
28065 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
28067 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
28068 if(!isWasmInitialized) {
28069 throw new Error("initializeWasm() must be awaited first!");
28071 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
28072 // debug statements here
28074 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
28076 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
28077 if(!isWasmInitialized) {
28078 throw new Error("initializeWasm() must be awaited first!");
28080 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
28081 return nativeResponseValue;
28083 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
28085 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
28086 if(!isWasmInitialized) {
28087 throw new Error("initializeWasm() must be awaited first!");
28089 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
28090 return nativeResponseValue;
28092 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ o);
28094 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o: bigint): bigint {
28095 if(!isWasmInitialized) {
28096 throw new Error("initializeWasm() must be awaited first!");
28098 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o);
28099 return nativeResponseValue;
28101 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(void);
28103 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(): bigint {
28104 if(!isWasmInitialized) {
28105 throw new Error("initializeWasm() must be awaited first!");
28107 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err();
28108 return nativeResponseValue;
28110 // bool CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR o);
28112 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o: bigint): boolean {
28113 if(!isWasmInitialized) {
28114 throw new Error("initializeWasm() must be awaited first!");
28116 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o);
28117 return nativeResponseValue;
28119 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ _res);
28121 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res: bigint): void {
28122 if(!isWasmInitialized) {
28123 throw new Error("initializeWasm() must be awaited first!");
28125 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res);
28126 // debug statements here
28128 // uint64_t CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR arg);
28130 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
28131 if(!isWasmInitialized) {
28132 throw new Error("initializeWasm() must be awaited first!");
28134 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg);
28135 return nativeResponseValue;
28137 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR orig);
28139 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig: bigint): bigint {
28140 if(!isWasmInitialized) {
28141 throw new Error("initializeWasm() must be awaited first!");
28143 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig);
28144 return nativeResponseValue;
28146 // void CVec_ForwardNodeZ_free(struct LDKCVec_ForwardNodeZ _res);
28148 export function CVec_ForwardNodeZ_free(_res: number): void {
28149 if(!isWasmInitialized) {
28150 throw new Error("initializeWasm() must be awaited first!");
28152 const nativeResponseValue = wasm.TS_CVec_ForwardNodeZ_free(_res);
28153 // debug statements here
28155 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
28157 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
28158 if(!isWasmInitialized) {
28159 throw new Error("initializeWasm() must be awaited first!");
28161 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
28162 return nativeResponseValue;
28164 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
28166 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
28167 if(!isWasmInitialized) {
28168 throw new Error("initializeWasm() must be awaited first!");
28170 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
28171 return nativeResponseValue;
28173 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
28175 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
28176 if(!isWasmInitialized) {
28177 throw new Error("initializeWasm() must be awaited first!");
28179 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
28180 return nativeResponseValue;
28182 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
28184 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
28185 if(!isWasmInitialized) {
28186 throw new Error("initializeWasm() must be awaited first!");
28188 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
28189 // debug statements here
28191 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
28193 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28194 if(!isWasmInitialized) {
28195 throw new Error("initializeWasm() must be awaited first!");
28197 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
28198 return nativeResponseValue;
28200 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
28202 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
28203 if(!isWasmInitialized) {
28204 throw new Error("initializeWasm() must be awaited first!");
28206 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
28207 return nativeResponseValue;
28209 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
28211 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
28212 if(!isWasmInitialized) {
28213 throw new Error("initializeWasm() must be awaited first!");
28215 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
28216 return nativeResponseValue;
28218 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
28220 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
28221 if(!isWasmInitialized) {
28222 throw new Error("initializeWasm() must be awaited first!");
28224 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
28225 return nativeResponseValue;
28227 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
28229 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
28230 if(!isWasmInitialized) {
28231 throw new Error("initializeWasm() must be awaited first!");
28233 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
28234 return nativeResponseValue;
28236 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
28238 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
28239 if(!isWasmInitialized) {
28240 throw new Error("initializeWasm() must be awaited first!");
28242 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
28243 // debug statements here
28245 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
28247 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28248 if(!isWasmInitialized) {
28249 throw new Error("initializeWasm() must be awaited first!");
28251 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
28252 return nativeResponseValue;
28254 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
28256 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
28257 if(!isWasmInitialized) {
28258 throw new Error("initializeWasm() must be awaited first!");
28260 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
28261 return nativeResponseValue;
28263 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_ok(struct LDKInvoiceError o);
28265 export function CResult_InvoiceErrorDecodeErrorZ_ok(o: bigint): bigint {
28266 if(!isWasmInitialized) {
28267 throw new Error("initializeWasm() must be awaited first!");
28269 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_ok(o);
28270 return nativeResponseValue;
28272 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_err(struct LDKDecodeError e);
28274 export function CResult_InvoiceErrorDecodeErrorZ_err(e: bigint): bigint {
28275 if(!isWasmInitialized) {
28276 throw new Error("initializeWasm() must be awaited first!");
28278 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_err(e);
28279 return nativeResponseValue;
28281 // bool CResult_InvoiceErrorDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR o);
28283 export function CResult_InvoiceErrorDecodeErrorZ_is_ok(o: bigint): boolean {
28284 if(!isWasmInitialized) {
28285 throw new Error("initializeWasm() must be awaited first!");
28287 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(o);
28288 return nativeResponseValue;
28290 // void CResult_InvoiceErrorDecodeErrorZ_free(struct LDKCResult_InvoiceErrorDecodeErrorZ _res);
28292 export function CResult_InvoiceErrorDecodeErrorZ_free(_res: bigint): void {
28293 if(!isWasmInitialized) {
28294 throw new Error("initializeWasm() must be awaited first!");
28296 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_free(_res);
28297 // debug statements here
28299 // uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg);
28301 export function CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28302 if(!isWasmInitialized) {
28303 throw new Error("initializeWasm() must be awaited first!");
28305 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg);
28306 return nativeResponseValue;
28308 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_clone(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR orig);
28310 export function CResult_InvoiceErrorDecodeErrorZ_clone(orig: bigint): bigint {
28311 if(!isWasmInitialized) {
28312 throw new Error("initializeWasm() must be awaited first!");
28314 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone(orig);
28315 return nativeResponseValue;
28317 // struct LDKCResult_TrackedSpendableOutputDecodeErrorZ CResult_TrackedSpendableOutputDecodeErrorZ_ok(struct LDKTrackedSpendableOutput o);
28319 export function CResult_TrackedSpendableOutputDecodeErrorZ_ok(o: bigint): bigint {
28320 if(!isWasmInitialized) {
28321 throw new Error("initializeWasm() must be awaited first!");
28323 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_ok(o);
28324 return nativeResponseValue;
28326 // struct LDKCResult_TrackedSpendableOutputDecodeErrorZ CResult_TrackedSpendableOutputDecodeErrorZ_err(struct LDKDecodeError e);
28328 export function CResult_TrackedSpendableOutputDecodeErrorZ_err(e: bigint): bigint {
28329 if(!isWasmInitialized) {
28330 throw new Error("initializeWasm() must be awaited first!");
28332 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_err(e);
28333 return nativeResponseValue;
28335 // bool CResult_TrackedSpendableOutputDecodeErrorZ_is_ok(const struct LDKCResult_TrackedSpendableOutputDecodeErrorZ *NONNULL_PTR o);
28337 export function CResult_TrackedSpendableOutputDecodeErrorZ_is_ok(o: bigint): boolean {
28338 if(!isWasmInitialized) {
28339 throw new Error("initializeWasm() must be awaited first!");
28341 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_is_ok(o);
28342 return nativeResponseValue;
28344 // void CResult_TrackedSpendableOutputDecodeErrorZ_free(struct LDKCResult_TrackedSpendableOutputDecodeErrorZ _res);
28346 export function CResult_TrackedSpendableOutputDecodeErrorZ_free(_res: bigint): void {
28347 if(!isWasmInitialized) {
28348 throw new Error("initializeWasm() must be awaited first!");
28350 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_free(_res);
28351 // debug statements here
28353 // uint64_t CResult_TrackedSpendableOutputDecodeErrorZ_clone_ptr(LDKCResult_TrackedSpendableOutputDecodeErrorZ *NONNULL_PTR arg);
28355 export function CResult_TrackedSpendableOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28356 if(!isWasmInitialized) {
28357 throw new Error("initializeWasm() must be awaited first!");
28359 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_clone_ptr(arg);
28360 return nativeResponseValue;
28362 // struct LDKCResult_TrackedSpendableOutputDecodeErrorZ CResult_TrackedSpendableOutputDecodeErrorZ_clone(const struct LDKCResult_TrackedSpendableOutputDecodeErrorZ *NONNULL_PTR orig);
28364 export function CResult_TrackedSpendableOutputDecodeErrorZ_clone(orig: bigint): bigint {
28365 if(!isWasmInitialized) {
28366 throw new Error("initializeWasm() must be awaited first!");
28368 const nativeResponseValue = wasm.TS_CResult_TrackedSpendableOutputDecodeErrorZ_clone(orig);
28369 return nativeResponseValue;
28371 // struct LDKCResult_OutputSpendStatusDecodeErrorZ CResult_OutputSpendStatusDecodeErrorZ_ok(struct LDKOutputSpendStatus o);
28373 export function CResult_OutputSpendStatusDecodeErrorZ_ok(o: bigint): bigint {
28374 if(!isWasmInitialized) {
28375 throw new Error("initializeWasm() must be awaited first!");
28377 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_ok(o);
28378 return nativeResponseValue;
28380 // struct LDKCResult_OutputSpendStatusDecodeErrorZ CResult_OutputSpendStatusDecodeErrorZ_err(struct LDKDecodeError e);
28382 export function CResult_OutputSpendStatusDecodeErrorZ_err(e: bigint): bigint {
28383 if(!isWasmInitialized) {
28384 throw new Error("initializeWasm() must be awaited first!");
28386 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_err(e);
28387 return nativeResponseValue;
28389 // bool CResult_OutputSpendStatusDecodeErrorZ_is_ok(const struct LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR o);
28391 export function CResult_OutputSpendStatusDecodeErrorZ_is_ok(o: bigint): boolean {
28392 if(!isWasmInitialized) {
28393 throw new Error("initializeWasm() must be awaited first!");
28395 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_is_ok(o);
28396 return nativeResponseValue;
28398 // void CResult_OutputSpendStatusDecodeErrorZ_free(struct LDKCResult_OutputSpendStatusDecodeErrorZ _res);
28400 export function CResult_OutputSpendStatusDecodeErrorZ_free(_res: bigint): void {
28401 if(!isWasmInitialized) {
28402 throw new Error("initializeWasm() must be awaited first!");
28404 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_free(_res);
28405 // debug statements here
28407 // uint64_t CResult_OutputSpendStatusDecodeErrorZ_clone_ptr(LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR arg);
28409 export function CResult_OutputSpendStatusDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28410 if(!isWasmInitialized) {
28411 throw new Error("initializeWasm() must be awaited first!");
28413 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_clone_ptr(arg);
28414 return nativeResponseValue;
28416 // struct LDKCResult_OutputSpendStatusDecodeErrorZ CResult_OutputSpendStatusDecodeErrorZ_clone(const struct LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR orig);
28418 export function CResult_OutputSpendStatusDecodeErrorZ_clone(orig: bigint): bigint {
28419 if(!isWasmInitialized) {
28420 throw new Error("initializeWasm() must be awaited first!");
28422 const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_clone(orig);
28423 return nativeResponseValue;
28425 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
28427 export function COption_FilterZ_some(o: bigint): bigint {
28428 if(!isWasmInitialized) {
28429 throw new Error("initializeWasm() must be awaited first!");
28431 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
28432 return nativeResponseValue;
28434 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
28436 export function COption_FilterZ_none(): bigint {
28437 if(!isWasmInitialized) {
28438 throw new Error("initializeWasm() must be awaited first!");
28440 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
28441 return nativeResponseValue;
28443 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
28445 export function COption_FilterZ_free(_res: bigint): void {
28446 if(!isWasmInitialized) {
28447 throw new Error("initializeWasm() must be awaited first!");
28449 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
28450 // debug statements here
28452 // void CVec_TrackedSpendableOutputZ_free(struct LDKCVec_TrackedSpendableOutputZ _res);
28454 export function CVec_TrackedSpendableOutputZ_free(_res: number): void {
28455 if(!isWasmInitialized) {
28456 throw new Error("initializeWasm() must be awaited first!");
28458 const nativeResponseValue = wasm.TS_CVec_TrackedSpendableOutputZ_free(_res);
28459 // debug statements here
28461 // struct LDKCResult_OutputSweeperDecodeErrorZ CResult_OutputSweeperDecodeErrorZ_ok(struct LDKOutputSweeper o);
28463 export function CResult_OutputSweeperDecodeErrorZ_ok(o: bigint): bigint {
28464 if(!isWasmInitialized) {
28465 throw new Error("initializeWasm() must be awaited first!");
28467 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_ok(o);
28468 return nativeResponseValue;
28470 // struct LDKCResult_OutputSweeperDecodeErrorZ CResult_OutputSweeperDecodeErrorZ_err(struct LDKDecodeError e);
28472 export function CResult_OutputSweeperDecodeErrorZ_err(e: bigint): bigint {
28473 if(!isWasmInitialized) {
28474 throw new Error("initializeWasm() must be awaited first!");
28476 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_err(e);
28477 return nativeResponseValue;
28479 // bool CResult_OutputSweeperDecodeErrorZ_is_ok(const struct LDKCResult_OutputSweeperDecodeErrorZ *NONNULL_PTR o);
28481 export function CResult_OutputSweeperDecodeErrorZ_is_ok(o: bigint): boolean {
28482 if(!isWasmInitialized) {
28483 throw new Error("initializeWasm() must be awaited first!");
28485 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_is_ok(o);
28486 return nativeResponseValue;
28488 // void CResult_OutputSweeperDecodeErrorZ_free(struct LDKCResult_OutputSweeperDecodeErrorZ _res);
28490 export function CResult_OutputSweeperDecodeErrorZ_free(_res: bigint): void {
28491 if(!isWasmInitialized) {
28492 throw new Error("initializeWasm() must be awaited first!");
28494 const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_free(_res);
28495 // debug statements here
28497 // struct LDKC2Tuple_BestBlockOutputSweeperZ C2Tuple_BestBlockOutputSweeperZ_new(struct LDKBestBlock a, struct LDKOutputSweeper b);
28499 export function C2Tuple_BestBlockOutputSweeperZ_new(a: bigint, b: bigint): bigint {
28500 if(!isWasmInitialized) {
28501 throw new Error("initializeWasm() must be awaited first!");
28503 const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_new(a, b);
28504 return nativeResponseValue;
28506 // void C2Tuple_BestBlockOutputSweeperZ_free(struct LDKC2Tuple_BestBlockOutputSweeperZ _res);
28508 export function C2Tuple_BestBlockOutputSweeperZ_free(_res: bigint): void {
28509 if(!isWasmInitialized) {
28510 throw new Error("initializeWasm() must be awaited first!");
28512 const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_free(_res);
28513 // debug statements here
28515 // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(struct LDKC2Tuple_BestBlockOutputSweeperZ o);
28517 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(o: bigint): bigint {
28518 if(!isWasmInitialized) {
28519 throw new Error("initializeWasm() must be awaited first!");
28521 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(o);
28522 return nativeResponseValue;
28524 // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(struct LDKDecodeError e);
28526 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(e: bigint): bigint {
28527 if(!isWasmInitialized) {
28528 throw new Error("initializeWasm() must be awaited first!");
28530 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(e);
28531 return nativeResponseValue;
28533 // bool CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ *NONNULL_PTR o);
28535 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(o: bigint): boolean {
28536 if(!isWasmInitialized) {
28537 throw new Error("initializeWasm() must be awaited first!");
28539 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(o);
28540 return nativeResponseValue;
28542 // void CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ _res);
28544 export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(_res: bigint): void {
28545 if(!isWasmInitialized) {
28546 throw new Error("initializeWasm() must be awaited first!");
28548 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(_res);
28549 // debug statements here
28551 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_ok(struct LDKDelayedPaymentBasepoint o);
28553 export function CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o: bigint): bigint {
28554 if(!isWasmInitialized) {
28555 throw new Error("initializeWasm() must be awaited first!");
28557 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o);
28558 return nativeResponseValue;
28560 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_err(struct LDKDecodeError e);
28562 export function CResult_DelayedPaymentBasepointDecodeErrorZ_err(e: bigint): bigint {
28563 if(!isWasmInitialized) {
28564 throw new Error("initializeWasm() must be awaited first!");
28566 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_err(e);
28567 return nativeResponseValue;
28569 // bool CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR o);
28571 export function CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
28572 if(!isWasmInitialized) {
28573 throw new Error("initializeWasm() must be awaited first!");
28575 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o);
28576 return nativeResponseValue;
28578 // void CResult_DelayedPaymentBasepointDecodeErrorZ_free(struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ _res);
28580 export function CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res: bigint): void {
28581 if(!isWasmInitialized) {
28582 throw new Error("initializeWasm() must be awaited first!");
28584 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res);
28585 // debug statements here
28587 // uint64_t CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR arg);
28589 export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28590 if(!isWasmInitialized) {
28591 throw new Error("initializeWasm() must be awaited first!");
28593 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg);
28594 return nativeResponseValue;
28596 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR orig);
28598 export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig: bigint): bigint {
28599 if(!isWasmInitialized) {
28600 throw new Error("initializeWasm() must be awaited first!");
28602 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig);
28603 return nativeResponseValue;
28605 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_ok(struct LDKDelayedPaymentKey o);
28607 export function CResult_DelayedPaymentKeyDecodeErrorZ_ok(o: bigint): bigint {
28608 if(!isWasmInitialized) {
28609 throw new Error("initializeWasm() must be awaited first!");
28611 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_ok(o);
28612 return nativeResponseValue;
28614 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_err(struct LDKDecodeError e);
28616 export function CResult_DelayedPaymentKeyDecodeErrorZ_err(e: bigint): bigint {
28617 if(!isWasmInitialized) {
28618 throw new Error("initializeWasm() must be awaited first!");
28620 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_err(e);
28621 return nativeResponseValue;
28623 // bool CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR o);
28625 export function CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o: bigint): boolean {
28626 if(!isWasmInitialized) {
28627 throw new Error("initializeWasm() must be awaited first!");
28629 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o);
28630 return nativeResponseValue;
28632 // void CResult_DelayedPaymentKeyDecodeErrorZ_free(struct LDKCResult_DelayedPaymentKeyDecodeErrorZ _res);
28634 export function CResult_DelayedPaymentKeyDecodeErrorZ_free(_res: bigint): void {
28635 if(!isWasmInitialized) {
28636 throw new Error("initializeWasm() must be awaited first!");
28638 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_free(_res);
28639 // debug statements here
28641 // uint64_t CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR arg);
28643 export function CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28644 if(!isWasmInitialized) {
28645 throw new Error("initializeWasm() must be awaited first!");
28647 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg);
28648 return nativeResponseValue;
28650 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR orig);
28652 export function CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig: bigint): bigint {
28653 if(!isWasmInitialized) {
28654 throw new Error("initializeWasm() must be awaited first!");
28656 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig);
28657 return nativeResponseValue;
28659 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_ok(struct LDKHtlcBasepoint o);
28661 export function CResult_HtlcBasepointDecodeErrorZ_ok(o: bigint): bigint {
28662 if(!isWasmInitialized) {
28663 throw new Error("initializeWasm() must be awaited first!");
28665 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_ok(o);
28666 return nativeResponseValue;
28668 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_err(struct LDKDecodeError e);
28670 export function CResult_HtlcBasepointDecodeErrorZ_err(e: bigint): bigint {
28671 if(!isWasmInitialized) {
28672 throw new Error("initializeWasm() must be awaited first!");
28674 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_err(e);
28675 return nativeResponseValue;
28677 // bool CResult_HtlcBasepointDecodeErrorZ_is_ok(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR o);
28679 export function CResult_HtlcBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
28680 if(!isWasmInitialized) {
28681 throw new Error("initializeWasm() must be awaited first!");
28683 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_is_ok(o);
28684 return nativeResponseValue;
28686 // void CResult_HtlcBasepointDecodeErrorZ_free(struct LDKCResult_HtlcBasepointDecodeErrorZ _res);
28688 export function CResult_HtlcBasepointDecodeErrorZ_free(_res: bigint): void {
28689 if(!isWasmInitialized) {
28690 throw new Error("initializeWasm() must be awaited first!");
28692 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_free(_res);
28693 // debug statements here
28695 // uint64_t CResult_HtlcBasepointDecodeErrorZ_clone_ptr(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR arg);
28697 export function CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28698 if(!isWasmInitialized) {
28699 throw new Error("initializeWasm() must be awaited first!");
28701 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg);
28702 return nativeResponseValue;
28704 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_clone(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR orig);
28706 export function CResult_HtlcBasepointDecodeErrorZ_clone(orig: bigint): bigint {
28707 if(!isWasmInitialized) {
28708 throw new Error("initializeWasm() must be awaited first!");
28710 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone(orig);
28711 return nativeResponseValue;
28713 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_ok(struct LDKHtlcKey o);
28715 export function CResult_HtlcKeyDecodeErrorZ_ok(o: bigint): bigint {
28716 if(!isWasmInitialized) {
28717 throw new Error("initializeWasm() must be awaited first!");
28719 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_ok(o);
28720 return nativeResponseValue;
28722 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_err(struct LDKDecodeError e);
28724 export function CResult_HtlcKeyDecodeErrorZ_err(e: bigint): bigint {
28725 if(!isWasmInitialized) {
28726 throw new Error("initializeWasm() must be awaited first!");
28728 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_err(e);
28729 return nativeResponseValue;
28731 // bool CResult_HtlcKeyDecodeErrorZ_is_ok(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR o);
28733 export function CResult_HtlcKeyDecodeErrorZ_is_ok(o: bigint): boolean {
28734 if(!isWasmInitialized) {
28735 throw new Error("initializeWasm() must be awaited first!");
28737 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_is_ok(o);
28738 return nativeResponseValue;
28740 // void CResult_HtlcKeyDecodeErrorZ_free(struct LDKCResult_HtlcKeyDecodeErrorZ _res);
28742 export function CResult_HtlcKeyDecodeErrorZ_free(_res: bigint): void {
28743 if(!isWasmInitialized) {
28744 throw new Error("initializeWasm() must be awaited first!");
28746 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_free(_res);
28747 // debug statements here
28749 // uint64_t CResult_HtlcKeyDecodeErrorZ_clone_ptr(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR arg);
28751 export function CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28752 if(!isWasmInitialized) {
28753 throw new Error("initializeWasm() must be awaited first!");
28755 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg);
28756 return nativeResponseValue;
28758 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_clone(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR orig);
28760 export function CResult_HtlcKeyDecodeErrorZ_clone(orig: bigint): bigint {
28761 if(!isWasmInitialized) {
28762 throw new Error("initializeWasm() must be awaited first!");
28764 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone(orig);
28765 return nativeResponseValue;
28767 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_ok(struct LDKRevocationBasepoint o);
28769 export function CResult_RevocationBasepointDecodeErrorZ_ok(o: bigint): bigint {
28770 if(!isWasmInitialized) {
28771 throw new Error("initializeWasm() must be awaited first!");
28773 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_ok(o);
28774 return nativeResponseValue;
28776 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_err(struct LDKDecodeError e);
28778 export function CResult_RevocationBasepointDecodeErrorZ_err(e: bigint): bigint {
28779 if(!isWasmInitialized) {
28780 throw new Error("initializeWasm() must be awaited first!");
28782 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_err(e);
28783 return nativeResponseValue;
28785 // bool CResult_RevocationBasepointDecodeErrorZ_is_ok(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR o);
28787 export function CResult_RevocationBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
28788 if(!isWasmInitialized) {
28789 throw new Error("initializeWasm() must be awaited first!");
28791 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_is_ok(o);
28792 return nativeResponseValue;
28794 // void CResult_RevocationBasepointDecodeErrorZ_free(struct LDKCResult_RevocationBasepointDecodeErrorZ _res);
28796 export function CResult_RevocationBasepointDecodeErrorZ_free(_res: bigint): void {
28797 if(!isWasmInitialized) {
28798 throw new Error("initializeWasm() must be awaited first!");
28800 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_free(_res);
28801 // debug statements here
28803 // uint64_t CResult_RevocationBasepointDecodeErrorZ_clone_ptr(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR arg);
28805 export function CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28806 if(!isWasmInitialized) {
28807 throw new Error("initializeWasm() must be awaited first!");
28809 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg);
28810 return nativeResponseValue;
28812 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_clone(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR orig);
28814 export function CResult_RevocationBasepointDecodeErrorZ_clone(orig: bigint): bigint {
28815 if(!isWasmInitialized) {
28816 throw new Error("initializeWasm() must be awaited first!");
28818 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone(orig);
28819 return nativeResponseValue;
28821 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_ok(struct LDKRevocationKey o);
28823 export function CResult_RevocationKeyDecodeErrorZ_ok(o: bigint): bigint {
28824 if(!isWasmInitialized) {
28825 throw new Error("initializeWasm() must be awaited first!");
28827 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_ok(o);
28828 return nativeResponseValue;
28830 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_err(struct LDKDecodeError e);
28832 export function CResult_RevocationKeyDecodeErrorZ_err(e: bigint): bigint {
28833 if(!isWasmInitialized) {
28834 throw new Error("initializeWasm() must be awaited first!");
28836 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_err(e);
28837 return nativeResponseValue;
28839 // bool CResult_RevocationKeyDecodeErrorZ_is_ok(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR o);
28841 export function CResult_RevocationKeyDecodeErrorZ_is_ok(o: bigint): boolean {
28842 if(!isWasmInitialized) {
28843 throw new Error("initializeWasm() must be awaited first!");
28845 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_is_ok(o);
28846 return nativeResponseValue;
28848 // void CResult_RevocationKeyDecodeErrorZ_free(struct LDKCResult_RevocationKeyDecodeErrorZ _res);
28850 export function CResult_RevocationKeyDecodeErrorZ_free(_res: bigint): void {
28851 if(!isWasmInitialized) {
28852 throw new Error("initializeWasm() must be awaited first!");
28854 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_free(_res);
28855 // debug statements here
28857 // uint64_t CResult_RevocationKeyDecodeErrorZ_clone_ptr(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR arg);
28859 export function CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
28860 if(!isWasmInitialized) {
28861 throw new Error("initializeWasm() must be awaited first!");
28863 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg);
28864 return nativeResponseValue;
28866 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_clone(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR orig);
28868 export function CResult_RevocationKeyDecodeErrorZ_clone(orig: bigint): bigint {
28869 if(!isWasmInitialized) {
28870 throw new Error("initializeWasm() must be awaited first!");
28872 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone(orig);
28873 return nativeResponseValue;
28875 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
28877 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
28878 if(!isWasmInitialized) {
28879 throw new Error("initializeWasm() must be awaited first!");
28881 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
28882 return nativeResponseValue;
28884 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
28886 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
28887 if(!isWasmInitialized) {
28888 throw new Error("initializeWasm() must be awaited first!");
28890 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
28891 return nativeResponseValue;
28893 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
28895 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
28896 if(!isWasmInitialized) {
28897 throw new Error("initializeWasm() must be awaited first!");
28899 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
28900 return nativeResponseValue;
28902 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
28904 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
28905 if(!isWasmInitialized) {
28906 throw new Error("initializeWasm() must be awaited first!");
28908 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
28909 // debug statements here
28911 // uint64_t C2Tuple_OutPointChannelIdZ_clone_ptr(LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR arg);
28913 export function C2Tuple_OutPointChannelIdZ_clone_ptr(arg: bigint): bigint {
28914 if(!isWasmInitialized) {
28915 throw new Error("initializeWasm() must be awaited first!");
28917 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_clone_ptr(arg);
28918 return nativeResponseValue;
28920 // struct LDKC2Tuple_OutPointChannelIdZ C2Tuple_OutPointChannelIdZ_clone(const struct LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR orig);
28922 export function C2Tuple_OutPointChannelIdZ_clone(orig: bigint): bigint {
28923 if(!isWasmInitialized) {
28924 throw new Error("initializeWasm() must be awaited first!");
28926 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_clone(orig);
28927 return nativeResponseValue;
28929 // struct LDKC2Tuple_OutPointChannelIdZ C2Tuple_OutPointChannelIdZ_new(struct LDKOutPoint a, struct LDKChannelId b);
28931 export function C2Tuple_OutPointChannelIdZ_new(a: bigint, b: bigint): bigint {
28932 if(!isWasmInitialized) {
28933 throw new Error("initializeWasm() must be awaited first!");
28935 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_new(a, b);
28936 return nativeResponseValue;
28938 // void C2Tuple_OutPointChannelIdZ_free(struct LDKC2Tuple_OutPointChannelIdZ _res);
28940 export function C2Tuple_OutPointChannelIdZ_free(_res: bigint): void {
28941 if(!isWasmInitialized) {
28942 throw new Error("initializeWasm() must be awaited first!");
28944 const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_free(_res);
28945 // debug statements here
28947 // void CVec_C2Tuple_OutPointChannelIdZZ_free(struct LDKCVec_C2Tuple_OutPointChannelIdZZ _res);
28949 export function CVec_C2Tuple_OutPointChannelIdZZ_free(_res: number): void {
28950 if(!isWasmInitialized) {
28951 throw new Error("initializeWasm() must be awaited first!");
28953 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointChannelIdZZ_free(_res);
28954 // debug statements here
28956 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
28958 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
28959 if(!isWasmInitialized) {
28960 throw new Error("initializeWasm() must be awaited first!");
28962 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
28963 // debug statements here
28965 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
28967 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
28968 if(!isWasmInitialized) {
28969 throw new Error("initializeWasm() must be awaited first!");
28971 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
28972 return nativeResponseValue;
28974 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
28976 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
28977 if(!isWasmInitialized) {
28978 throw new Error("initializeWasm() must be awaited first!");
28980 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
28981 return nativeResponseValue;
28983 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
28985 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
28986 if(!isWasmInitialized) {
28987 throw new Error("initializeWasm() must be awaited first!");
28989 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
28990 return nativeResponseValue;
28992 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
28994 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
28995 if(!isWasmInitialized) {
28996 throw new Error("initializeWasm() must be awaited first!");
28998 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
28999 // debug statements here
29001 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
29003 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
29004 if(!isWasmInitialized) {
29005 throw new Error("initializeWasm() must be awaited first!");
29007 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
29008 // debug statements here
29010 // void APIError_free(struct LDKAPIError this_ptr);
29012 export function APIError_free(this_ptr: bigint): void {
29013 if(!isWasmInitialized) {
29014 throw new Error("initializeWasm() must be awaited first!");
29016 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
29017 // debug statements here
29019 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
29021 export function APIError_clone_ptr(arg: bigint): bigint {
29022 if(!isWasmInitialized) {
29023 throw new Error("initializeWasm() must be awaited first!");
29025 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
29026 return nativeResponseValue;
29028 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
29030 export function APIError_clone(orig: bigint): bigint {
29031 if(!isWasmInitialized) {
29032 throw new Error("initializeWasm() must be awaited first!");
29034 const nativeResponseValue = wasm.TS_APIError_clone(orig);
29035 return nativeResponseValue;
29037 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
29039 export function APIError_apimisuse_error(err: number): bigint {
29040 if(!isWasmInitialized) {
29041 throw new Error("initializeWasm() must be awaited first!");
29043 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
29044 return nativeResponseValue;
29046 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
29048 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
29049 if(!isWasmInitialized) {
29050 throw new Error("initializeWasm() must be awaited first!");
29052 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
29053 return nativeResponseValue;
29055 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
29057 export function APIError_invalid_route(err: number): bigint {
29058 if(!isWasmInitialized) {
29059 throw new Error("initializeWasm() must be awaited first!");
29061 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
29062 return nativeResponseValue;
29064 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
29066 export function APIError_channel_unavailable(err: number): bigint {
29067 if(!isWasmInitialized) {
29068 throw new Error("initializeWasm() must be awaited first!");
29070 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
29071 return nativeResponseValue;
29073 // struct LDKAPIError APIError_monitor_update_in_progress(void);
29075 export function APIError_monitor_update_in_progress(): bigint {
29076 if(!isWasmInitialized) {
29077 throw new Error("initializeWasm() must be awaited first!");
29079 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
29080 return nativeResponseValue;
29082 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
29084 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
29085 if(!isWasmInitialized) {
29086 throw new Error("initializeWasm() must be awaited first!");
29088 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
29089 return nativeResponseValue;
29091 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
29093 export function APIError_eq(a: bigint, b: bigint): boolean {
29094 if(!isWasmInitialized) {
29095 throw new Error("initializeWasm() must be awaited first!");
29097 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
29098 return nativeResponseValue;
29100 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
29102 export function APIError_write(obj: bigint): number {
29103 if(!isWasmInitialized) {
29104 throw new Error("initializeWasm() must be awaited first!");
29106 const nativeResponseValue = wasm.TS_APIError_write(obj);
29107 return nativeResponseValue;
29109 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
29111 export function APIError_read(ser: number): bigint {
29112 if(!isWasmInitialized) {
29113 throw new Error("initializeWasm() must be awaited first!");
29115 const nativeResponseValue = wasm.TS_APIError_read(ser);
29116 return nativeResponseValue;
29118 // void BigSize_free(struct LDKBigSize this_obj);
29120 export function BigSize_free(this_obj: bigint): void {
29121 if(!isWasmInitialized) {
29122 throw new Error("initializeWasm() must be awaited first!");
29124 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
29125 // debug statements here
29127 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
29129 export function BigSize_get_a(this_ptr: bigint): bigint {
29130 if(!isWasmInitialized) {
29131 throw new Error("initializeWasm() must be awaited first!");
29133 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
29134 return nativeResponseValue;
29136 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
29138 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
29139 if(!isWasmInitialized) {
29140 throw new Error("initializeWasm() must be awaited first!");
29142 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
29143 // debug statements here
29145 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
29147 export function BigSize_new(a_arg: bigint): bigint {
29148 if(!isWasmInitialized) {
29149 throw new Error("initializeWasm() must be awaited first!");
29151 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
29152 return nativeResponseValue;
29154 // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
29156 export function BigSize_clone_ptr(arg: bigint): bigint {
29157 if(!isWasmInitialized) {
29158 throw new Error("initializeWasm() must be awaited first!");
29160 const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
29161 return nativeResponseValue;
29163 // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
29165 export function BigSize_clone(orig: bigint): bigint {
29166 if(!isWasmInitialized) {
29167 throw new Error("initializeWasm() must be awaited first!");
29169 const nativeResponseValue = wasm.TS_BigSize_clone(orig);
29170 return nativeResponseValue;
29172 // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
29174 export function BigSize_hash(o: bigint): bigint {
29175 if(!isWasmInitialized) {
29176 throw new Error("initializeWasm() must be awaited first!");
29178 const nativeResponseValue = wasm.TS_BigSize_hash(o);
29179 return nativeResponseValue;
29181 // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
29183 export function BigSize_eq(a: bigint, b: bigint): boolean {
29184 if(!isWasmInitialized) {
29185 throw new Error("initializeWasm() must be awaited first!");
29187 const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
29188 return nativeResponseValue;
29190 // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
29192 export function BigSize_write(obj: bigint): number {
29193 if(!isWasmInitialized) {
29194 throw new Error("initializeWasm() must be awaited first!");
29196 const nativeResponseValue = wasm.TS_BigSize_write(obj);
29197 return nativeResponseValue;
29199 // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
29201 export function BigSize_read(ser: number): bigint {
29202 if(!isWasmInitialized) {
29203 throw new Error("initializeWasm() must be awaited first!");
29205 const nativeResponseValue = wasm.TS_BigSize_read(ser);
29206 return nativeResponseValue;
29208 // void Hostname_free(struct LDKHostname this_obj);
29210 export function Hostname_free(this_obj: bigint): void {
29211 if(!isWasmInitialized) {
29212 throw new Error("initializeWasm() must be awaited first!");
29214 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
29215 // debug statements here
29217 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
29219 export function Hostname_clone_ptr(arg: bigint): bigint {
29220 if(!isWasmInitialized) {
29221 throw new Error("initializeWasm() must be awaited first!");
29223 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
29224 return nativeResponseValue;
29226 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
29228 export function Hostname_clone(orig: bigint): bigint {
29229 if(!isWasmInitialized) {
29230 throw new Error("initializeWasm() must be awaited first!");
29232 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
29233 return nativeResponseValue;
29235 // uint64_t Hostname_hash(const struct LDKHostname *NONNULL_PTR o);
29237 export function Hostname_hash(o: bigint): bigint {
29238 if(!isWasmInitialized) {
29239 throw new Error("initializeWasm() must be awaited first!");
29241 const nativeResponseValue = wasm.TS_Hostname_hash(o);
29242 return nativeResponseValue;
29244 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
29246 export function Hostname_eq(a: bigint, b: bigint): boolean {
29247 if(!isWasmInitialized) {
29248 throw new Error("initializeWasm() must be awaited first!");
29250 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
29251 return nativeResponseValue;
29253 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
29255 export function Hostname_len(this_arg: bigint): number {
29256 if(!isWasmInitialized) {
29257 throw new Error("initializeWasm() must be awaited first!");
29259 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
29260 return nativeResponseValue;
29262 // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
29264 export function Hostname_write(obj: bigint): number {
29265 if(!isWasmInitialized) {
29266 throw new Error("initializeWasm() must be awaited first!");
29268 const nativeResponseValue = wasm.TS_Hostname_write(obj);
29269 return nativeResponseValue;
29271 // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
29273 export function Hostname_read(ser: number): bigint {
29274 if(!isWasmInitialized) {
29275 throw new Error("initializeWasm() must be awaited first!");
29277 const nativeResponseValue = wasm.TS_Hostname_read(ser);
29278 return nativeResponseValue;
29280 // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
29282 export function TransactionU16LenLimited_free(this_obj: bigint): void {
29283 if(!isWasmInitialized) {
29284 throw new Error("initializeWasm() must be awaited first!");
29286 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
29287 // debug statements here
29289 // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
29291 export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
29292 if(!isWasmInitialized) {
29293 throw new Error("initializeWasm() must be awaited first!");
29295 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
29296 return nativeResponseValue;
29298 // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
29300 export function TransactionU16LenLimited_clone(orig: bigint): bigint {
29301 if(!isWasmInitialized) {
29302 throw new Error("initializeWasm() must be awaited first!");
29304 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
29305 return nativeResponseValue;
29307 // uint64_t TransactionU16LenLimited_hash(const struct LDKTransactionU16LenLimited *NONNULL_PTR o);
29309 export function TransactionU16LenLimited_hash(o: bigint): bigint {
29310 if(!isWasmInitialized) {
29311 throw new Error("initializeWasm() must be awaited first!");
29313 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_hash(o);
29314 return nativeResponseValue;
29316 // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
29318 export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
29319 if(!isWasmInitialized) {
29320 throw new Error("initializeWasm() must be awaited first!");
29322 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
29323 return nativeResponseValue;
29325 // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
29327 export function TransactionU16LenLimited_new(transaction: number): bigint {
29328 if(!isWasmInitialized) {
29329 throw new Error("initializeWasm() must be awaited first!");
29331 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
29332 return nativeResponseValue;
29334 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
29336 export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
29337 if(!isWasmInitialized) {
29338 throw new Error("initializeWasm() must be awaited first!");
29340 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
29341 return nativeResponseValue;
29343 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_as_transaction(const struct LDKTransactionU16LenLimited *NONNULL_PTR this_arg);
29345 export function TransactionU16LenLimited_as_transaction(this_arg: bigint): number {
29346 if(!isWasmInitialized) {
29347 throw new Error("initializeWasm() must be awaited first!");
29349 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_as_transaction(this_arg);
29350 return nativeResponseValue;
29352 // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
29354 export function TransactionU16LenLimited_write(obj: bigint): number {
29355 if(!isWasmInitialized) {
29356 throw new Error("initializeWasm() must be awaited first!");
29358 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
29359 return nativeResponseValue;
29361 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
29363 export function TransactionU16LenLimited_read(ser: number): bigint {
29364 if(!isWasmInitialized) {
29365 throw new Error("initializeWasm() must be awaited first!");
29367 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
29368 return nativeResponseValue;
29370 // struct LDKCResult_StrSecp256k1ErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
29372 export function sign(msg: number, sk: number): bigint {
29373 if(!isWasmInitialized) {
29374 throw new Error("initializeWasm() must be awaited first!");
29376 const nativeResponseValue = wasm.TS_sign(msg, sk);
29377 return nativeResponseValue;
29379 // struct LDKCResult_PublicKeySecp256k1ErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
29381 export function recover_pk(msg: number, sig: number): bigint {
29382 if(!isWasmInitialized) {
29383 throw new Error("initializeWasm() must be awaited first!");
29385 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
29386 return nativeResponseValue;
29388 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
29390 export function verify(msg: number, sig: number, pk: number): boolean {
29391 if(!isWasmInitialized) {
29392 throw new Error("initializeWasm() must be awaited first!");
29394 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
29395 return nativeResponseValue;
29397 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
29399 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
29400 if(!isWasmInitialized) {
29401 throw new Error("initializeWasm() must be awaited first!");
29403 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
29404 return nativeResponseValue;
29406 // void KVStore_free(struct LDKKVStore this_ptr);
29408 export function KVStore_free(this_ptr: bigint): void {
29409 if(!isWasmInitialized) {
29410 throw new Error("initializeWasm() must be awaited first!");
29412 const nativeResponseValue = wasm.TS_KVStore_free(this_ptr);
29413 // debug statements here
29415 // void Persister_free(struct LDKPersister this_ptr);
29417 export function Persister_free(this_ptr: bigint): void {
29418 if(!isWasmInitialized) {
29419 throw new Error("initializeWasm() must be awaited first!");
29421 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
29422 // debug statements here
29424 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ read_channel_monitors(struct LDKKVStore kv_store, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
29426 export function read_channel_monitors(kv_store: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
29427 if(!isWasmInitialized) {
29428 throw new Error("initializeWasm() must be awaited first!");
29430 const nativeResponseValue = wasm.TS_read_channel_monitors(kv_store, entropy_source, signer_provider);
29431 return nativeResponseValue;
29433 // void MonitorUpdatingPersister_free(struct LDKMonitorUpdatingPersister this_obj);
29435 export function MonitorUpdatingPersister_free(this_obj: bigint): void {
29436 if(!isWasmInitialized) {
29437 throw new Error("initializeWasm() must be awaited first!");
29439 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_free(this_obj);
29440 // debug statements here
29442 // MUST_USE_RES struct LDKMonitorUpdatingPersister MonitorUpdatingPersister_new(struct LDKKVStore kv_store, struct LDKLogger logger, uint64_t maximum_pending_updates, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
29444 export function MonitorUpdatingPersister_new(kv_store: bigint, logger: bigint, maximum_pending_updates: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
29445 if(!isWasmInitialized) {
29446 throw new Error("initializeWasm() must be awaited first!");
29448 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_new(kv_store, logger, maximum_pending_updates, entropy_source, signer_provider);
29449 return nativeResponseValue;
29451 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ MonitorUpdatingPersister_read_all_channel_monitors_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator);
29453 export function MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint): bigint {
29454 if(!isWasmInitialized) {
29455 throw new Error("initializeWasm() must be awaited first!");
29457 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg, broadcaster, fee_estimator);
29458 return nativeResponseValue;
29460 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ MonitorUpdatingPersister_read_channel_monitor_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, struct LDKStr monitor_key);
29462 export function MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, monitor_key: number): bigint {
29463 if(!isWasmInitialized) {
29464 throw new Error("initializeWasm() must be awaited first!");
29466 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg, broadcaster, fee_estimator, monitor_key);
29467 return nativeResponseValue;
29469 // MUST_USE_RES struct LDKCResult_NoneIOErrorZ MonitorUpdatingPersister_cleanup_stale_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, bool lazy);
29471 export function MonitorUpdatingPersister_cleanup_stale_updates(this_arg: bigint, lazy: boolean): bigint {
29472 if(!isWasmInitialized) {
29473 throw new Error("initializeWasm() must be awaited first!");
29475 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_cleanup_stale_updates(this_arg, lazy);
29476 return nativeResponseValue;
29478 // struct LDKPersist MonitorUpdatingPersister_as_Persist(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg);
29480 export function MonitorUpdatingPersister_as_Persist(this_arg: bigint): bigint {
29481 if(!isWasmInitialized) {
29482 throw new Error("initializeWasm() must be awaited first!");
29484 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_as_Persist(this_arg);
29485 return nativeResponseValue;
29487 // enum LDKShortChannelIdError ShortChannelIdError_clone(const enum LDKShortChannelIdError *NONNULL_PTR orig);
29489 export function ShortChannelIdError_clone(orig: bigint): ShortChannelIdError {
29490 if(!isWasmInitialized) {
29491 throw new Error("initializeWasm() must be awaited first!");
29493 const nativeResponseValue = wasm.TS_ShortChannelIdError_clone(orig);
29494 return nativeResponseValue;
29496 // enum LDKShortChannelIdError ShortChannelIdError_block_overflow(void);
29498 export function ShortChannelIdError_block_overflow(): ShortChannelIdError {
29499 if(!isWasmInitialized) {
29500 throw new Error("initializeWasm() must be awaited first!");
29502 const nativeResponseValue = wasm.TS_ShortChannelIdError_block_overflow();
29503 return nativeResponseValue;
29505 // enum LDKShortChannelIdError ShortChannelIdError_tx_index_overflow(void);
29507 export function ShortChannelIdError_tx_index_overflow(): ShortChannelIdError {
29508 if(!isWasmInitialized) {
29509 throw new Error("initializeWasm() must be awaited first!");
29511 const nativeResponseValue = wasm.TS_ShortChannelIdError_tx_index_overflow();
29512 return nativeResponseValue;
29514 // enum LDKShortChannelIdError ShortChannelIdError_vout_index_overflow(void);
29516 export function ShortChannelIdError_vout_index_overflow(): ShortChannelIdError {
29517 if(!isWasmInitialized) {
29518 throw new Error("initializeWasm() must be awaited first!");
29520 const nativeResponseValue = wasm.TS_ShortChannelIdError_vout_index_overflow();
29521 return nativeResponseValue;
29523 // bool ShortChannelIdError_eq(const enum LDKShortChannelIdError *NONNULL_PTR a, const enum LDKShortChannelIdError *NONNULL_PTR b);
29525 export function ShortChannelIdError_eq(a: bigint, b: bigint): boolean {
29526 if(!isWasmInitialized) {
29527 throw new Error("initializeWasm() must be awaited first!");
29529 const nativeResponseValue = wasm.TS_ShortChannelIdError_eq(a, b);
29530 return nativeResponseValue;
29532 // uint32_t block_from_scid(uint64_t short_channel_id);
29534 export function block_from_scid(short_channel_id: bigint): number {
29535 if(!isWasmInitialized) {
29536 throw new Error("initializeWasm() must be awaited first!");
29538 const nativeResponseValue = wasm.TS_block_from_scid(short_channel_id);
29539 return nativeResponseValue;
29541 // uint32_t tx_index_from_scid(uint64_t short_channel_id);
29543 export function tx_index_from_scid(short_channel_id: bigint): number {
29544 if(!isWasmInitialized) {
29545 throw new Error("initializeWasm() must be awaited first!");
29547 const nativeResponseValue = wasm.TS_tx_index_from_scid(short_channel_id);
29548 return nativeResponseValue;
29550 // uint16_t vout_from_scid(uint64_t short_channel_id);
29552 export function vout_from_scid(short_channel_id: bigint): number {
29553 if(!isWasmInitialized) {
29554 throw new Error("initializeWasm() must be awaited first!");
29556 const nativeResponseValue = wasm.TS_vout_from_scid(short_channel_id);
29557 return nativeResponseValue;
29559 // struct LDKCResult_u64ShortChannelIdErrorZ scid_from_parts(uint64_t block, uint64_t tx_index, uint64_t vout_index);
29561 export function scid_from_parts(block: bigint, tx_index: bigint, vout_index: bigint): bigint {
29562 if(!isWasmInitialized) {
29563 throw new Error("initializeWasm() must be awaited first!");
29565 const nativeResponseValue = wasm.TS_scid_from_parts(block, tx_index, vout_index);
29566 return nativeResponseValue;
29568 // void UntrustedString_free(struct LDKUntrustedString this_obj);
29570 export function UntrustedString_free(this_obj: bigint): void {
29571 if(!isWasmInitialized) {
29572 throw new Error("initializeWasm() must be awaited first!");
29574 const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
29575 // debug statements here
29577 // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
29579 export function UntrustedString_get_a(this_ptr: bigint): number {
29580 if(!isWasmInitialized) {
29581 throw new Error("initializeWasm() must be awaited first!");
29583 const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
29584 return nativeResponseValue;
29586 // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
29588 export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
29589 if(!isWasmInitialized) {
29590 throw new Error("initializeWasm() must be awaited first!");
29592 const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
29593 // debug statements here
29595 // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
29597 export function UntrustedString_new(a_arg: number): bigint {
29598 if(!isWasmInitialized) {
29599 throw new Error("initializeWasm() must be awaited first!");
29601 const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
29602 return nativeResponseValue;
29604 // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
29606 export function UntrustedString_clone_ptr(arg: bigint): bigint {
29607 if(!isWasmInitialized) {
29608 throw new Error("initializeWasm() must be awaited first!");
29610 const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
29611 return nativeResponseValue;
29613 // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
29615 export function UntrustedString_clone(orig: bigint): bigint {
29616 if(!isWasmInitialized) {
29617 throw new Error("initializeWasm() must be awaited first!");
29619 const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
29620 return nativeResponseValue;
29622 // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
29624 export function UntrustedString_eq(a: bigint, b: bigint): boolean {
29625 if(!isWasmInitialized) {
29626 throw new Error("initializeWasm() must be awaited first!");
29628 const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
29629 return nativeResponseValue;
29631 // uint64_t UntrustedString_hash(const struct LDKUntrustedString *NONNULL_PTR o);
29633 export function UntrustedString_hash(o: bigint): bigint {
29634 if(!isWasmInitialized) {
29635 throw new Error("initializeWasm() must be awaited first!");
29637 const nativeResponseValue = wasm.TS_UntrustedString_hash(o);
29638 return nativeResponseValue;
29640 // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
29642 export function UntrustedString_write(obj: bigint): number {
29643 if(!isWasmInitialized) {
29644 throw new Error("initializeWasm() must be awaited first!");
29646 const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
29647 return nativeResponseValue;
29649 // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
29651 export function UntrustedString_read(ser: number): bigint {
29652 if(!isWasmInitialized) {
29653 throw new Error("initializeWasm() must be awaited first!");
29655 const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
29656 return nativeResponseValue;
29658 // void PrintableString_free(struct LDKPrintableString this_obj);
29660 export function PrintableString_free(this_obj: bigint): void {
29661 if(!isWasmInitialized) {
29662 throw new Error("initializeWasm() must be awaited first!");
29664 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
29665 // debug statements here
29667 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
29669 export function PrintableString_get_a(this_ptr: bigint): number {
29670 if(!isWasmInitialized) {
29671 throw new Error("initializeWasm() must be awaited first!");
29673 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
29674 return nativeResponseValue;
29676 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
29678 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
29679 if(!isWasmInitialized) {
29680 throw new Error("initializeWasm() must be awaited first!");
29682 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
29683 // debug statements here
29685 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
29687 export function PrintableString_new(a_arg: number): bigint {
29688 if(!isWasmInitialized) {
29689 throw new Error("initializeWasm() must be awaited first!");
29691 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
29692 return nativeResponseValue;
29694 // void TrackedSpendableOutput_free(struct LDKTrackedSpendableOutput this_obj);
29696 export function TrackedSpendableOutput_free(this_obj: bigint): void {
29697 if(!isWasmInitialized) {
29698 throw new Error("initializeWasm() must be awaited first!");
29700 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_free(this_obj);
29701 // debug statements here
29703 // struct LDKSpendableOutputDescriptor TrackedSpendableOutput_get_descriptor(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
29705 export function TrackedSpendableOutput_get_descriptor(this_ptr: bigint): bigint {
29706 if(!isWasmInitialized) {
29707 throw new Error("initializeWasm() must be awaited first!");
29709 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_descriptor(this_ptr);
29710 return nativeResponseValue;
29712 // void TrackedSpendableOutput_set_descriptor(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKSpendableOutputDescriptor val);
29714 export function TrackedSpendableOutput_set_descriptor(this_ptr: bigint, val: bigint): void {
29715 if(!isWasmInitialized) {
29716 throw new Error("initializeWasm() must be awaited first!");
29718 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_descriptor(this_ptr, val);
29719 // debug statements here
29721 // struct LDKChannelId TrackedSpendableOutput_get_channel_id(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
29723 export function TrackedSpendableOutput_get_channel_id(this_ptr: bigint): bigint {
29724 if(!isWasmInitialized) {
29725 throw new Error("initializeWasm() must be awaited first!");
29727 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_channel_id(this_ptr);
29728 return nativeResponseValue;
29730 // void TrackedSpendableOutput_set_channel_id(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKChannelId val);
29732 export function TrackedSpendableOutput_set_channel_id(this_ptr: bigint, val: bigint): void {
29733 if(!isWasmInitialized) {
29734 throw new Error("initializeWasm() must be awaited first!");
29736 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_channel_id(this_ptr, val);
29737 // debug statements here
29739 // struct LDKOutputSpendStatus TrackedSpendableOutput_get_status(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
29741 export function TrackedSpendableOutput_get_status(this_ptr: bigint): bigint {
29742 if(!isWasmInitialized) {
29743 throw new Error("initializeWasm() must be awaited first!");
29745 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_status(this_ptr);
29746 return nativeResponseValue;
29748 // void TrackedSpendableOutput_set_status(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKOutputSpendStatus val);
29750 export function TrackedSpendableOutput_set_status(this_ptr: bigint, val: bigint): void {
29751 if(!isWasmInitialized) {
29752 throw new Error("initializeWasm() must be awaited first!");
29754 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_status(this_ptr, val);
29755 // debug statements here
29757 // MUST_USE_RES struct LDKTrackedSpendableOutput TrackedSpendableOutput_new(struct LDKSpendableOutputDescriptor descriptor_arg, struct LDKChannelId channel_id_arg, struct LDKOutputSpendStatus status_arg);
29759 export function TrackedSpendableOutput_new(descriptor_arg: bigint, channel_id_arg: bigint, status_arg: bigint): bigint {
29760 if(!isWasmInitialized) {
29761 throw new Error("initializeWasm() must be awaited first!");
29763 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_new(descriptor_arg, channel_id_arg, status_arg);
29764 return nativeResponseValue;
29766 // uint64_t TrackedSpendableOutput_clone_ptr(LDKTrackedSpendableOutput *NONNULL_PTR arg);
29768 export function TrackedSpendableOutput_clone_ptr(arg: bigint): bigint {
29769 if(!isWasmInitialized) {
29770 throw new Error("initializeWasm() must be awaited first!");
29772 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_clone_ptr(arg);
29773 return nativeResponseValue;
29775 // struct LDKTrackedSpendableOutput TrackedSpendableOutput_clone(const struct LDKTrackedSpendableOutput *NONNULL_PTR orig);
29777 export function TrackedSpendableOutput_clone(orig: bigint): bigint {
29778 if(!isWasmInitialized) {
29779 throw new Error("initializeWasm() must be awaited first!");
29781 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_clone(orig);
29782 return nativeResponseValue;
29784 // bool TrackedSpendableOutput_eq(const struct LDKTrackedSpendableOutput *NONNULL_PTR a, const struct LDKTrackedSpendableOutput *NONNULL_PTR b);
29786 export function TrackedSpendableOutput_eq(a: bigint, b: bigint): boolean {
29787 if(!isWasmInitialized) {
29788 throw new Error("initializeWasm() must be awaited first!");
29790 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_eq(a, b);
29791 return nativeResponseValue;
29793 // MUST_USE_RES bool TrackedSpendableOutput_is_spent_in(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_arg, struct LDKTransaction tx);
29795 export function TrackedSpendableOutput_is_spent_in(this_arg: bigint, tx: number): boolean {
29796 if(!isWasmInitialized) {
29797 throw new Error("initializeWasm() must be awaited first!");
29799 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_is_spent_in(this_arg, tx);
29800 return nativeResponseValue;
29802 // struct LDKCVec_u8Z TrackedSpendableOutput_write(const struct LDKTrackedSpendableOutput *NONNULL_PTR obj);
29804 export function TrackedSpendableOutput_write(obj: bigint): number {
29805 if(!isWasmInitialized) {
29806 throw new Error("initializeWasm() must be awaited first!");
29808 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_write(obj);
29809 return nativeResponseValue;
29811 // struct LDKCResult_TrackedSpendableOutputDecodeErrorZ TrackedSpendableOutput_read(struct LDKu8slice ser);
29813 export function TrackedSpendableOutput_read(ser: number): bigint {
29814 if(!isWasmInitialized) {
29815 throw new Error("initializeWasm() must be awaited first!");
29817 const nativeResponseValue = wasm.TS_TrackedSpendableOutput_read(ser);
29818 return nativeResponseValue;
29820 // void OutputSpendStatus_free(struct LDKOutputSpendStatus this_ptr);
29822 export function OutputSpendStatus_free(this_ptr: bigint): void {
29823 if(!isWasmInitialized) {
29824 throw new Error("initializeWasm() must be awaited first!");
29826 const nativeResponseValue = wasm.TS_OutputSpendStatus_free(this_ptr);
29827 // debug statements here
29829 // uint64_t OutputSpendStatus_clone_ptr(LDKOutputSpendStatus *NONNULL_PTR arg);
29831 export function OutputSpendStatus_clone_ptr(arg: bigint): bigint {
29832 if(!isWasmInitialized) {
29833 throw new Error("initializeWasm() must be awaited first!");
29835 const nativeResponseValue = wasm.TS_OutputSpendStatus_clone_ptr(arg);
29836 return nativeResponseValue;
29838 // struct LDKOutputSpendStatus OutputSpendStatus_clone(const struct LDKOutputSpendStatus *NONNULL_PTR orig);
29840 export function OutputSpendStatus_clone(orig: bigint): bigint {
29841 if(!isWasmInitialized) {
29842 throw new Error("initializeWasm() must be awaited first!");
29844 const nativeResponseValue = wasm.TS_OutputSpendStatus_clone(orig);
29845 return nativeResponseValue;
29847 // struct LDKOutputSpendStatus OutputSpendStatus_pending_initial_broadcast(struct LDKCOption_u32Z delayed_until_height);
29849 export function OutputSpendStatus_pending_initial_broadcast(delayed_until_height: bigint): bigint {
29850 if(!isWasmInitialized) {
29851 throw new Error("initializeWasm() must be awaited first!");
29853 const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_initial_broadcast(delayed_until_height);
29854 return nativeResponseValue;
29856 // struct LDKOutputSpendStatus OutputSpendStatus_pending_first_confirmation(struct LDKThirtyTwoBytes first_broadcast_hash, uint32_t latest_broadcast_height, struct LDKTransaction latest_spending_tx);
29858 export function OutputSpendStatus_pending_first_confirmation(first_broadcast_hash: number, latest_broadcast_height: number, latest_spending_tx: number): bigint {
29859 if(!isWasmInitialized) {
29860 throw new Error("initializeWasm() must be awaited first!");
29862 const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_first_confirmation(first_broadcast_hash, latest_broadcast_height, latest_spending_tx);
29863 return nativeResponseValue;
29865 // struct LDKOutputSpendStatus OutputSpendStatus_pending_threshold_confirmations(struct LDKThirtyTwoBytes first_broadcast_hash, uint32_t latest_broadcast_height, struct LDKTransaction latest_spending_tx, uint32_t confirmation_height, struct LDKThirtyTwoBytes confirmation_hash);
29867 export function OutputSpendStatus_pending_threshold_confirmations(first_broadcast_hash: number, latest_broadcast_height: number, latest_spending_tx: number, confirmation_height: number, confirmation_hash: number): bigint {
29868 if(!isWasmInitialized) {
29869 throw new Error("initializeWasm() must be awaited first!");
29871 const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_threshold_confirmations(first_broadcast_hash, latest_broadcast_height, latest_spending_tx, confirmation_height, confirmation_hash);
29872 return nativeResponseValue;
29874 // bool OutputSpendStatus_eq(const struct LDKOutputSpendStatus *NONNULL_PTR a, const struct LDKOutputSpendStatus *NONNULL_PTR b);
29876 export function OutputSpendStatus_eq(a: bigint, b: bigint): boolean {
29877 if(!isWasmInitialized) {
29878 throw new Error("initializeWasm() must be awaited first!");
29880 const nativeResponseValue = wasm.TS_OutputSpendStatus_eq(a, b);
29881 return nativeResponseValue;
29883 // struct LDKCVec_u8Z OutputSpendStatus_write(const struct LDKOutputSpendStatus *NONNULL_PTR obj);
29885 export function OutputSpendStatus_write(obj: bigint): number {
29886 if(!isWasmInitialized) {
29887 throw new Error("initializeWasm() must be awaited first!");
29889 const nativeResponseValue = wasm.TS_OutputSpendStatus_write(obj);
29890 return nativeResponseValue;
29892 // struct LDKCResult_OutputSpendStatusDecodeErrorZ OutputSpendStatus_read(struct LDKu8slice ser);
29894 export function OutputSpendStatus_read(ser: number): bigint {
29895 if(!isWasmInitialized) {
29896 throw new Error("initializeWasm() must be awaited first!");
29898 const nativeResponseValue = wasm.TS_OutputSpendStatus_read(ser);
29899 return nativeResponseValue;
29901 // void OutputSweeper_free(struct LDKOutputSweeper this_obj);
29903 export function OutputSweeper_free(this_obj: bigint): void {
29904 if(!isWasmInitialized) {
29905 throw new Error("initializeWasm() must be awaited first!");
29907 const nativeResponseValue = wasm.TS_OutputSweeper_free(this_obj);
29908 // debug statements here
29910 // MUST_USE_RES struct LDKOutputSweeper OutputSweeper_new(struct LDKBestBlock best_block, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKCOption_FilterZ chain_data_source, struct LDKOutputSpender output_spender, struct LDKChangeDestinationSource change_destination_source, struct LDKKVStore kv_store, struct LDKLogger logger);
29912 export function OutputSweeper_new(best_block: bigint, broadcaster: bigint, fee_estimator: bigint, chain_data_source: bigint, output_spender: bigint, change_destination_source: bigint, kv_store: bigint, logger: bigint): bigint {
29913 if(!isWasmInitialized) {
29914 throw new Error("initializeWasm() must be awaited first!");
29916 const nativeResponseValue = wasm.TS_OutputSweeper_new(best_block, broadcaster, fee_estimator, chain_data_source, output_spender, change_destination_source, kv_store, logger);
29917 return nativeResponseValue;
29919 // MUST_USE_RES struct LDKCResult_NoneNoneZ OutputSweeper_track_spendable_outputs(const struct LDKOutputSweeper *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ output_descriptors, struct LDKChannelId channel_id, bool exclude_static_outputs, struct LDKCOption_u32Z delay_until_height);
29921 export function OutputSweeper_track_spendable_outputs(this_arg: bigint, output_descriptors: number, channel_id: bigint, exclude_static_outputs: boolean, delay_until_height: bigint): bigint {
29922 if(!isWasmInitialized) {
29923 throw new Error("initializeWasm() must be awaited first!");
29925 const nativeResponseValue = wasm.TS_OutputSweeper_track_spendable_outputs(this_arg, output_descriptors, channel_id, exclude_static_outputs, delay_until_height);
29926 return nativeResponseValue;
29928 // MUST_USE_RES struct LDKCVec_TrackedSpendableOutputZ OutputSweeper_tracked_spendable_outputs(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
29930 export function OutputSweeper_tracked_spendable_outputs(this_arg: bigint): number {
29931 if(!isWasmInitialized) {
29932 throw new Error("initializeWasm() must be awaited first!");
29934 const nativeResponseValue = wasm.TS_OutputSweeper_tracked_spendable_outputs(this_arg);
29935 return nativeResponseValue;
29937 // MUST_USE_RES struct LDKBestBlock OutputSweeper_current_best_block(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
29939 export function OutputSweeper_current_best_block(this_arg: bigint): bigint {
29940 if(!isWasmInitialized) {
29941 throw new Error("initializeWasm() must be awaited first!");
29943 const nativeResponseValue = wasm.TS_OutputSweeper_current_best_block(this_arg);
29944 return nativeResponseValue;
29946 // struct LDKListen OutputSweeper_as_Listen(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
29948 export function OutputSweeper_as_Listen(this_arg: bigint): bigint {
29949 if(!isWasmInitialized) {
29950 throw new Error("initializeWasm() must be awaited first!");
29952 const nativeResponseValue = wasm.TS_OutputSweeper_as_Listen(this_arg);
29953 return nativeResponseValue;
29955 // struct LDKConfirm OutputSweeper_as_Confirm(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
29957 export function OutputSweeper_as_Confirm(this_arg: bigint): bigint {
29958 if(!isWasmInitialized) {
29959 throw new Error("initializeWasm() must be awaited first!");
29961 const nativeResponseValue = wasm.TS_OutputSweeper_as_Confirm(this_arg);
29962 return nativeResponseValue;
29964 // void SpendingDelay_free(struct LDKSpendingDelay this_ptr);
29966 export function SpendingDelay_free(this_ptr: bigint): void {
29967 if(!isWasmInitialized) {
29968 throw new Error("initializeWasm() must be awaited first!");
29970 const nativeResponseValue = wasm.TS_SpendingDelay_free(this_ptr);
29971 // debug statements here
29973 // uint64_t SpendingDelay_clone_ptr(LDKSpendingDelay *NONNULL_PTR arg);
29975 export function SpendingDelay_clone_ptr(arg: bigint): bigint {
29976 if(!isWasmInitialized) {
29977 throw new Error("initializeWasm() must be awaited first!");
29979 const nativeResponseValue = wasm.TS_SpendingDelay_clone_ptr(arg);
29980 return nativeResponseValue;
29982 // struct LDKSpendingDelay SpendingDelay_clone(const struct LDKSpendingDelay *NONNULL_PTR orig);
29984 export function SpendingDelay_clone(orig: bigint): bigint {
29985 if(!isWasmInitialized) {
29986 throw new Error("initializeWasm() must be awaited first!");
29988 const nativeResponseValue = wasm.TS_SpendingDelay_clone(orig);
29989 return nativeResponseValue;
29991 // struct LDKSpendingDelay SpendingDelay_relative(uint32_t num_blocks);
29993 export function SpendingDelay_relative(num_blocks: number): bigint {
29994 if(!isWasmInitialized) {
29995 throw new Error("initializeWasm() must be awaited first!");
29997 const nativeResponseValue = wasm.TS_SpendingDelay_relative(num_blocks);
29998 return nativeResponseValue;
30000 // struct LDKSpendingDelay SpendingDelay_absolute(uint32_t height);
30002 export function SpendingDelay_absolute(height: number): bigint {
30003 if(!isWasmInitialized) {
30004 throw new Error("initializeWasm() must be awaited first!");
30006 const nativeResponseValue = wasm.TS_SpendingDelay_absolute(height);
30007 return nativeResponseValue;
30009 // struct LDKCResult_OutputSweeperDecodeErrorZ OutputSweeper_read(struct LDKu8slice ser, struct LDKBroadcasterInterface arg_a, struct LDKFeeEstimator arg_b, struct LDKCOption_FilterZ arg_c, struct LDKOutputSpender arg_d, struct LDKChangeDestinationSource arg_e, struct LDKKVStore arg_f, struct LDKLogger arg_g);
30011 export function OutputSweeper_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint, arg_d: bigint, arg_e: bigint, arg_f: bigint, arg_g: bigint): bigint {
30012 if(!isWasmInitialized) {
30013 throw new Error("initializeWasm() must be awaited first!");
30015 const nativeResponseValue = wasm.TS_OutputSweeper_read(ser, arg_a, arg_b, arg_c, arg_d, arg_e, arg_f, arg_g);
30016 return nativeResponseValue;
30018 // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ C2Tuple_BestBlockOutputSweeperZ_read(struct LDKu8slice ser, struct LDKBroadcasterInterface arg_a, struct LDKFeeEstimator arg_b, struct LDKCOption_FilterZ arg_c, struct LDKOutputSpender arg_d, struct LDKChangeDestinationSource arg_e, struct LDKKVStore arg_f, struct LDKLogger arg_g);
30020 export function C2Tuple_BestBlockOutputSweeperZ_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint, arg_d: bigint, arg_e: bigint, arg_f: bigint, arg_g: bigint): bigint {
30021 if(!isWasmInitialized) {
30022 throw new Error("initializeWasm() must be awaited first!");
30024 const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_read(ser, arg_a, arg_b, arg_c, arg_d, arg_e, arg_f, arg_g);
30025 return nativeResponseValue;
30027 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
30029 export function FutureCallback_free(this_ptr: bigint): void {
30030 if(!isWasmInitialized) {
30031 throw new Error("initializeWasm() must be awaited first!");
30033 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
30034 // debug statements here
30036 // void Future_free(struct LDKFuture this_obj);
30038 export function Future_free(this_obj: bigint): void {
30039 if(!isWasmInitialized) {
30040 throw new Error("initializeWasm() must be awaited first!");
30042 const nativeResponseValue = wasm.TS_Future_free(this_obj);
30043 // debug statements here
30045 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
30047 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
30048 if(!isWasmInitialized) {
30049 throw new Error("initializeWasm() must be awaited first!");
30051 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
30052 // debug statements here
30054 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
30056 export function Level_clone(orig: bigint): Level {
30057 if(!isWasmInitialized) {
30058 throw new Error("initializeWasm() must be awaited first!");
30060 const nativeResponseValue = wasm.TS_Level_clone(orig);
30061 return nativeResponseValue;
30063 // enum LDKLevel Level_gossip(void);
30065 export function Level_gossip(): Level {
30066 if(!isWasmInitialized) {
30067 throw new Error("initializeWasm() must be awaited first!");
30069 const nativeResponseValue = wasm.TS_Level_gossip();
30070 return nativeResponseValue;
30072 // enum LDKLevel Level_trace(void);
30074 export function Level_trace(): Level {
30075 if(!isWasmInitialized) {
30076 throw new Error("initializeWasm() must be awaited first!");
30078 const nativeResponseValue = wasm.TS_Level_trace();
30079 return nativeResponseValue;
30081 // enum LDKLevel Level_debug(void);
30083 export function Level_debug(): Level {
30084 if(!isWasmInitialized) {
30085 throw new Error("initializeWasm() must be awaited first!");
30087 const nativeResponseValue = wasm.TS_Level_debug();
30088 return nativeResponseValue;
30090 // enum LDKLevel Level_info(void);
30092 export function Level_info(): Level {
30093 if(!isWasmInitialized) {
30094 throw new Error("initializeWasm() must be awaited first!");
30096 const nativeResponseValue = wasm.TS_Level_info();
30097 return nativeResponseValue;
30099 // enum LDKLevel Level_warn(void);
30101 export function Level_warn(): Level {
30102 if(!isWasmInitialized) {
30103 throw new Error("initializeWasm() must be awaited first!");
30105 const nativeResponseValue = wasm.TS_Level_warn();
30106 return nativeResponseValue;
30108 // enum LDKLevel Level_error(void);
30110 export function Level_error(): Level {
30111 if(!isWasmInitialized) {
30112 throw new Error("initializeWasm() must be awaited first!");
30114 const nativeResponseValue = wasm.TS_Level_error();
30115 return nativeResponseValue;
30117 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
30119 export function Level_eq(a: bigint, b: bigint): boolean {
30120 if(!isWasmInitialized) {
30121 throw new Error("initializeWasm() must be awaited first!");
30123 const nativeResponseValue = wasm.TS_Level_eq(a, b);
30124 return nativeResponseValue;
30126 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
30128 export function Level_hash(o: bigint): bigint {
30129 if(!isWasmInitialized) {
30130 throw new Error("initializeWasm() must be awaited first!");
30132 const nativeResponseValue = wasm.TS_Level_hash(o);
30133 return nativeResponseValue;
30135 // MUST_USE_RES enum LDKLevel Level_max(void);
30137 export function Level_max(): Level {
30138 if(!isWasmInitialized) {
30139 throw new Error("initializeWasm() must be awaited first!");
30141 const nativeResponseValue = wasm.TS_Level_max();
30142 return nativeResponseValue;
30144 // void Record_free(struct LDKRecord this_obj);
30146 export function Record_free(this_obj: bigint): void {
30147 if(!isWasmInitialized) {
30148 throw new Error("initializeWasm() must be awaited first!");
30150 const nativeResponseValue = wasm.TS_Record_free(this_obj);
30151 // debug statements here
30153 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
30155 export function Record_get_level(this_ptr: bigint): Level {
30156 if(!isWasmInitialized) {
30157 throw new Error("initializeWasm() must be awaited first!");
30159 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
30160 return nativeResponseValue;
30162 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
30164 export function Record_set_level(this_ptr: bigint, val: Level): void {
30165 if(!isWasmInitialized) {
30166 throw new Error("initializeWasm() must be awaited first!");
30168 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
30169 // debug statements here
30171 // struct LDKPublicKey Record_get_peer_id(const struct LDKRecord *NONNULL_PTR this_ptr);
30173 export function Record_get_peer_id(this_ptr: bigint): number {
30174 if(!isWasmInitialized) {
30175 throw new Error("initializeWasm() must be awaited first!");
30177 const nativeResponseValue = wasm.TS_Record_get_peer_id(this_ptr);
30178 return nativeResponseValue;
30180 // void Record_set_peer_id(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30182 export function Record_set_peer_id(this_ptr: bigint, val: number): void {
30183 if(!isWasmInitialized) {
30184 throw new Error("initializeWasm() must be awaited first!");
30186 const nativeResponseValue = wasm.TS_Record_set_peer_id(this_ptr, val);
30187 // debug statements here
30189 // struct LDKChannelId Record_get_channel_id(const struct LDKRecord *NONNULL_PTR this_ptr);
30191 export function Record_get_channel_id(this_ptr: bigint): bigint {
30192 if(!isWasmInitialized) {
30193 throw new Error("initializeWasm() must be awaited first!");
30195 const nativeResponseValue = wasm.TS_Record_get_channel_id(this_ptr);
30196 return nativeResponseValue;
30198 // void Record_set_channel_id(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKChannelId val);
30200 export function Record_set_channel_id(this_ptr: bigint, val: bigint): void {
30201 if(!isWasmInitialized) {
30202 throw new Error("initializeWasm() must be awaited first!");
30204 const nativeResponseValue = wasm.TS_Record_set_channel_id(this_ptr, val);
30205 // debug statements here
30207 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
30209 export function Record_get_args(this_ptr: bigint): number {
30210 if(!isWasmInitialized) {
30211 throw new Error("initializeWasm() must be awaited first!");
30213 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
30214 return nativeResponseValue;
30216 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
30218 export function Record_set_args(this_ptr: bigint, val: number): void {
30219 if(!isWasmInitialized) {
30220 throw new Error("initializeWasm() must be awaited first!");
30222 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
30223 // debug statements here
30225 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
30227 export function Record_get_module_path(this_ptr: bigint): number {
30228 if(!isWasmInitialized) {
30229 throw new Error("initializeWasm() must be awaited first!");
30231 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
30232 return nativeResponseValue;
30234 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
30236 export function Record_set_module_path(this_ptr: bigint, val: number): void {
30237 if(!isWasmInitialized) {
30238 throw new Error("initializeWasm() must be awaited first!");
30240 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
30241 // debug statements here
30243 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
30245 export function Record_get_file(this_ptr: bigint): number {
30246 if(!isWasmInitialized) {
30247 throw new Error("initializeWasm() must be awaited first!");
30249 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
30250 return nativeResponseValue;
30252 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
30254 export function Record_set_file(this_ptr: bigint, val: number): void {
30255 if(!isWasmInitialized) {
30256 throw new Error("initializeWasm() must be awaited first!");
30258 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
30259 // debug statements here
30261 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
30263 export function Record_get_line(this_ptr: bigint): number {
30264 if(!isWasmInitialized) {
30265 throw new Error("initializeWasm() must be awaited first!");
30267 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
30268 return nativeResponseValue;
30270 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
30272 export function Record_set_line(this_ptr: bigint, val: number): void {
30273 if(!isWasmInitialized) {
30274 throw new Error("initializeWasm() must be awaited first!");
30276 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
30277 // debug statements here
30279 // MUST_USE_RES struct LDKRecord Record_new(enum LDKLevel level_arg, struct LDKPublicKey peer_id_arg, struct LDKChannelId channel_id_arg, struct LDKStr args_arg, struct LDKStr module_path_arg, struct LDKStr file_arg, uint32_t line_arg);
30281 export function Record_new(level_arg: Level, peer_id_arg: number, channel_id_arg: bigint, args_arg: number, module_path_arg: number, file_arg: number, line_arg: number): bigint {
30282 if(!isWasmInitialized) {
30283 throw new Error("initializeWasm() must be awaited first!");
30285 const nativeResponseValue = wasm.TS_Record_new(level_arg, peer_id_arg, channel_id_arg, args_arg, module_path_arg, file_arg, line_arg);
30286 return nativeResponseValue;
30288 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
30290 export function Record_clone_ptr(arg: bigint): bigint {
30291 if(!isWasmInitialized) {
30292 throw new Error("initializeWasm() must be awaited first!");
30294 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
30295 return nativeResponseValue;
30297 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
30299 export function Record_clone(orig: bigint): bigint {
30300 if(!isWasmInitialized) {
30301 throw new Error("initializeWasm() must be awaited first!");
30303 const nativeResponseValue = wasm.TS_Record_clone(orig);
30304 return nativeResponseValue;
30306 // void Logger_free(struct LDKLogger this_ptr);
30308 export function Logger_free(this_ptr: bigint): void {
30309 if(!isWasmInitialized) {
30310 throw new Error("initializeWasm() must be awaited first!");
30312 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
30313 // debug statements here
30315 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
30317 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
30318 if(!isWasmInitialized) {
30319 throw new Error("initializeWasm() must be awaited first!");
30321 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
30322 // debug statements here
30324 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30326 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
30327 if(!isWasmInitialized) {
30328 throw new Error("initializeWasm() must be awaited first!");
30330 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
30331 return nativeResponseValue;
30333 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
30335 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
30336 if(!isWasmInitialized) {
30337 throw new Error("initializeWasm() must be awaited first!");
30339 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
30340 // debug statements here
30342 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30344 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
30345 if(!isWasmInitialized) {
30346 throw new Error("initializeWasm() must be awaited first!");
30348 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
30349 return nativeResponseValue;
30351 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
30353 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
30354 if(!isWasmInitialized) {
30355 throw new Error("initializeWasm() must be awaited first!");
30357 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
30358 // debug statements here
30360 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30362 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
30363 if(!isWasmInitialized) {
30364 throw new Error("initializeWasm() must be awaited first!");
30366 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
30367 return nativeResponseValue;
30369 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
30371 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30372 if(!isWasmInitialized) {
30373 throw new Error("initializeWasm() must be awaited first!");
30375 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
30376 // debug statements here
30378 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30380 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
30381 if(!isWasmInitialized) {
30382 throw new Error("initializeWasm() must be awaited first!");
30384 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
30385 return nativeResponseValue;
30387 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
30389 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
30390 if(!isWasmInitialized) {
30391 throw new Error("initializeWasm() must be awaited first!");
30393 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
30394 // debug statements here
30396 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30398 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
30399 if(!isWasmInitialized) {
30400 throw new Error("initializeWasm() must be awaited first!");
30402 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
30403 return nativeResponseValue;
30405 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
30407 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
30408 if(!isWasmInitialized) {
30409 throw new Error("initializeWasm() must be awaited first!");
30411 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
30412 // debug statements here
30414 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30416 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
30417 if(!isWasmInitialized) {
30418 throw new Error("initializeWasm() must be awaited first!");
30420 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
30421 return nativeResponseValue;
30423 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
30425 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
30426 if(!isWasmInitialized) {
30427 throw new Error("initializeWasm() must be awaited first!");
30429 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
30430 // debug statements here
30432 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30434 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
30435 if(!isWasmInitialized) {
30436 throw new Error("initializeWasm() must be awaited first!");
30438 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
30439 return nativeResponseValue;
30441 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
30443 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
30444 if(!isWasmInitialized) {
30445 throw new Error("initializeWasm() must be awaited first!");
30447 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
30448 // debug statements here
30450 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30452 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
30453 if(!isWasmInitialized) {
30454 throw new Error("initializeWasm() must be awaited first!");
30456 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
30457 return nativeResponseValue;
30459 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
30461 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
30462 if(!isWasmInitialized) {
30463 throw new Error("initializeWasm() must be awaited first!");
30465 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
30466 // debug statements here
30468 // bool ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30470 export function ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint): boolean {
30471 if(!isWasmInitialized) {
30472 throw new Error("initializeWasm() must be awaited first!");
30474 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr);
30475 return nativeResponseValue;
30477 // void ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
30479 export function ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint, val: boolean): void {
30480 if(!isWasmInitialized) {
30481 throw new Error("initializeWasm() must be awaited first!");
30483 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr, val);
30484 // debug statements here
30486 // uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
30488 export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
30489 if(!isWasmInitialized) {
30490 throw new Error("initializeWasm() must be awaited first!");
30492 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
30493 return nativeResponseValue;
30495 // void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
30497 export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30498 if(!isWasmInitialized) {
30499 throw new Error("initializeWasm() must be awaited first!");
30501 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
30502 // debug statements here
30504 // 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, bool negotiate_anchors_zero_fee_htlc_tx_arg, uint16_t our_max_accepted_htlcs_arg);
30506 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, negotiate_anchors_zero_fee_htlc_tx_arg: boolean, our_max_accepted_htlcs_arg: number): bigint {
30507 if(!isWasmInitialized) {
30508 throw new Error("initializeWasm() must be awaited first!");
30510 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, negotiate_anchors_zero_fee_htlc_tx_arg, our_max_accepted_htlcs_arg);
30511 return nativeResponseValue;
30513 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
30515 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
30516 if(!isWasmInitialized) {
30517 throw new Error("initializeWasm() must be awaited first!");
30519 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
30520 return nativeResponseValue;
30522 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
30524 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
30525 if(!isWasmInitialized) {
30526 throw new Error("initializeWasm() must be awaited first!");
30528 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
30529 return nativeResponseValue;
30531 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
30533 export function ChannelHandshakeConfig_default(): bigint {
30534 if(!isWasmInitialized) {
30535 throw new Error("initializeWasm() must be awaited first!");
30537 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
30538 return nativeResponseValue;
30540 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
30542 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
30543 if(!isWasmInitialized) {
30544 throw new Error("initializeWasm() must be awaited first!");
30546 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
30547 // debug statements here
30549 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30551 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
30552 if(!isWasmInitialized) {
30553 throw new Error("initializeWasm() must be awaited first!");
30555 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
30556 return nativeResponseValue;
30558 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
30560 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
30561 if(!isWasmInitialized) {
30562 throw new Error("initializeWasm() must be awaited first!");
30564 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
30565 // debug statements here
30567 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30569 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
30570 if(!isWasmInitialized) {
30571 throw new Error("initializeWasm() must be awaited first!");
30573 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
30574 return nativeResponseValue;
30576 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
30578 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
30579 if(!isWasmInitialized) {
30580 throw new Error("initializeWasm() must be awaited first!");
30582 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
30583 // debug statements here
30585 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30587 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
30588 if(!isWasmInitialized) {
30589 throw new Error("initializeWasm() must be awaited first!");
30591 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
30592 return nativeResponseValue;
30594 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
30596 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30597 if(!isWasmInitialized) {
30598 throw new Error("initializeWasm() must be awaited first!");
30600 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
30601 // debug statements here
30603 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30605 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30606 if(!isWasmInitialized) {
30607 throw new Error("initializeWasm() must be awaited first!");
30609 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
30610 return nativeResponseValue;
30612 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
30614 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30615 if(!isWasmInitialized) {
30616 throw new Error("initializeWasm() must be awaited first!");
30618 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
30619 // debug statements here
30621 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30623 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
30624 if(!isWasmInitialized) {
30625 throw new Error("initializeWasm() must be awaited first!");
30627 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
30628 return nativeResponseValue;
30630 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
30632 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
30633 if(!isWasmInitialized) {
30634 throw new Error("initializeWasm() must be awaited first!");
30636 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
30637 // debug statements here
30639 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30641 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
30642 if(!isWasmInitialized) {
30643 throw new Error("initializeWasm() must be awaited first!");
30645 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
30646 return nativeResponseValue;
30648 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
30650 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30651 if(!isWasmInitialized) {
30652 throw new Error("initializeWasm() must be awaited first!");
30654 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
30655 // debug statements here
30657 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30659 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
30660 if(!isWasmInitialized) {
30661 throw new Error("initializeWasm() must be awaited first!");
30663 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
30664 return nativeResponseValue;
30666 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
30668 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
30669 if(!isWasmInitialized) {
30670 throw new Error("initializeWasm() must be awaited first!");
30672 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
30673 // debug statements here
30675 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30677 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
30678 if(!isWasmInitialized) {
30679 throw new Error("initializeWasm() must be awaited first!");
30681 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
30682 return nativeResponseValue;
30684 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
30686 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
30687 if(!isWasmInitialized) {
30688 throw new Error("initializeWasm() must be awaited first!");
30690 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
30691 // debug statements here
30693 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30695 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
30696 if(!isWasmInitialized) {
30697 throw new Error("initializeWasm() must be awaited first!");
30699 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
30700 return nativeResponseValue;
30702 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
30704 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
30705 if(!isWasmInitialized) {
30706 throw new Error("initializeWasm() must be awaited first!");
30708 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
30709 // debug statements here
30711 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
30713 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
30714 if(!isWasmInitialized) {
30715 throw new Error("initializeWasm() must be awaited first!");
30717 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
30718 return nativeResponseValue;
30720 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
30722 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
30723 if(!isWasmInitialized) {
30724 throw new Error("initializeWasm() must be awaited first!");
30726 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
30727 // debug statements here
30729 // 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);
30731 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 {
30732 if(!isWasmInitialized) {
30733 throw new Error("initializeWasm() must be awaited first!");
30735 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);
30736 return nativeResponseValue;
30738 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
30740 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
30741 if(!isWasmInitialized) {
30742 throw new Error("initializeWasm() must be awaited first!");
30744 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
30745 return nativeResponseValue;
30747 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
30749 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
30750 if(!isWasmInitialized) {
30751 throw new Error("initializeWasm() must be awaited first!");
30753 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
30754 return nativeResponseValue;
30756 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
30758 export function ChannelHandshakeLimits_default(): bigint {
30759 if(!isWasmInitialized) {
30760 throw new Error("initializeWasm() must be awaited first!");
30762 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
30763 return nativeResponseValue;
30765 // void MaxDustHTLCExposure_free(struct LDKMaxDustHTLCExposure this_ptr);
30767 export function MaxDustHTLCExposure_free(this_ptr: bigint): void {
30768 if(!isWasmInitialized) {
30769 throw new Error("initializeWasm() must be awaited first!");
30771 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_free(this_ptr);
30772 // debug statements here
30774 // uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg);
30776 export function MaxDustHTLCExposure_clone_ptr(arg: bigint): bigint {
30777 if(!isWasmInitialized) {
30778 throw new Error("initializeWasm() must be awaited first!");
30780 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone_ptr(arg);
30781 return nativeResponseValue;
30783 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_clone(const struct LDKMaxDustHTLCExposure *NONNULL_PTR orig);
30785 export function MaxDustHTLCExposure_clone(orig: bigint): bigint {
30786 if(!isWasmInitialized) {
30787 throw new Error("initializeWasm() must be awaited first!");
30789 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone(orig);
30790 return nativeResponseValue;
30792 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fixed_limit_msat(uint64_t a);
30794 export function MaxDustHTLCExposure_fixed_limit_msat(a: bigint): bigint {
30795 if(!isWasmInitialized) {
30796 throw new Error("initializeWasm() must be awaited first!");
30798 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fixed_limit_msat(a);
30799 return nativeResponseValue;
30801 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fee_rate_multiplier(uint64_t a);
30803 export function MaxDustHTLCExposure_fee_rate_multiplier(a: bigint): bigint {
30804 if(!isWasmInitialized) {
30805 throw new Error("initializeWasm() must be awaited first!");
30807 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fee_rate_multiplier(a);
30808 return nativeResponseValue;
30810 // bool MaxDustHTLCExposure_eq(const struct LDKMaxDustHTLCExposure *NONNULL_PTR a, const struct LDKMaxDustHTLCExposure *NONNULL_PTR b);
30812 export function MaxDustHTLCExposure_eq(a: bigint, b: bigint): boolean {
30813 if(!isWasmInitialized) {
30814 throw new Error("initializeWasm() must be awaited first!");
30816 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_eq(a, b);
30817 return nativeResponseValue;
30819 // struct LDKCVec_u8Z MaxDustHTLCExposure_write(const struct LDKMaxDustHTLCExposure *NONNULL_PTR obj);
30821 export function MaxDustHTLCExposure_write(obj: bigint): number {
30822 if(!isWasmInitialized) {
30823 throw new Error("initializeWasm() must be awaited first!");
30825 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_write(obj);
30826 return nativeResponseValue;
30828 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ MaxDustHTLCExposure_read(struct LDKu8slice ser);
30830 export function MaxDustHTLCExposure_read(ser: number): bigint {
30831 if(!isWasmInitialized) {
30832 throw new Error("initializeWasm() must be awaited first!");
30834 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_read(ser);
30835 return nativeResponseValue;
30837 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
30839 export function ChannelConfig_free(this_obj: bigint): void {
30840 if(!isWasmInitialized) {
30841 throw new Error("initializeWasm() must be awaited first!");
30843 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
30844 // debug statements here
30846 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30848 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
30849 if(!isWasmInitialized) {
30850 throw new Error("initializeWasm() must be awaited first!");
30852 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
30853 return nativeResponseValue;
30855 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
30857 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
30858 if(!isWasmInitialized) {
30859 throw new Error("initializeWasm() must be awaited first!");
30861 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
30862 // debug statements here
30864 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30866 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
30867 if(!isWasmInitialized) {
30868 throw new Error("initializeWasm() must be awaited first!");
30870 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
30871 return nativeResponseValue;
30873 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
30875 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
30876 if(!isWasmInitialized) {
30877 throw new Error("initializeWasm() must be awaited first!");
30879 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
30880 // debug statements here
30882 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30884 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
30885 if(!isWasmInitialized) {
30886 throw new Error("initializeWasm() must be awaited first!");
30888 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
30889 return nativeResponseValue;
30891 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
30893 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
30894 if(!isWasmInitialized) {
30895 throw new Error("initializeWasm() must be awaited first!");
30897 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
30898 // debug statements here
30900 // struct LDKMaxDustHTLCExposure ChannelConfig_get_max_dust_htlc_exposure(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30902 export function ChannelConfig_get_max_dust_htlc_exposure(this_ptr: bigint): bigint {
30903 if(!isWasmInitialized) {
30904 throw new Error("initializeWasm() must be awaited first!");
30906 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure(this_ptr);
30907 return nativeResponseValue;
30909 // void ChannelConfig_set_max_dust_htlc_exposure(struct LDKChannelConfig *NONNULL_PTR this_ptr, struct LDKMaxDustHTLCExposure val);
30911 export function ChannelConfig_set_max_dust_htlc_exposure(this_ptr: bigint, val: bigint): void {
30912 if(!isWasmInitialized) {
30913 throw new Error("initializeWasm() must be awaited first!");
30915 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure(this_ptr, val);
30916 // debug statements here
30918 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30920 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
30921 if(!isWasmInitialized) {
30922 throw new Error("initializeWasm() must be awaited first!");
30924 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
30925 return nativeResponseValue;
30927 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
30929 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
30930 if(!isWasmInitialized) {
30931 throw new Error("initializeWasm() must be awaited first!");
30933 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
30934 // debug statements here
30936 // bool ChannelConfig_get_accept_underpaying_htlcs(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
30938 export function ChannelConfig_get_accept_underpaying_htlcs(this_ptr: bigint): boolean {
30939 if(!isWasmInitialized) {
30940 throw new Error("initializeWasm() must be awaited first!");
30942 const nativeResponseValue = wasm.TS_ChannelConfig_get_accept_underpaying_htlcs(this_ptr);
30943 return nativeResponseValue;
30945 // void ChannelConfig_set_accept_underpaying_htlcs(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
30947 export function ChannelConfig_set_accept_underpaying_htlcs(this_ptr: bigint, val: boolean): void {
30948 if(!isWasmInitialized) {
30949 throw new Error("initializeWasm() must be awaited first!");
30951 const nativeResponseValue = wasm.TS_ChannelConfig_set_accept_underpaying_htlcs(this_ptr, val);
30952 // debug statements here
30954 // 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, struct LDKMaxDustHTLCExposure max_dust_htlc_exposure_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg, bool accept_underpaying_htlcs_arg);
30956 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_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint, accept_underpaying_htlcs_arg: boolean): bigint {
30957 if(!isWasmInitialized) {
30958 throw new Error("initializeWasm() must be awaited first!");
30960 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_arg, force_close_avoidance_max_fee_satoshis_arg, accept_underpaying_htlcs_arg);
30961 return nativeResponseValue;
30963 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
30965 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
30966 if(!isWasmInitialized) {
30967 throw new Error("initializeWasm() must be awaited first!");
30969 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
30970 return nativeResponseValue;
30972 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
30974 export function ChannelConfig_clone(orig: bigint): bigint {
30975 if(!isWasmInitialized) {
30976 throw new Error("initializeWasm() must be awaited first!");
30978 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
30979 return nativeResponseValue;
30981 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
30983 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
30984 if(!isWasmInitialized) {
30985 throw new Error("initializeWasm() must be awaited first!");
30987 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
30988 return nativeResponseValue;
30990 // void ChannelConfig_apply(struct LDKChannelConfig *NONNULL_PTR this_arg, const struct LDKChannelConfigUpdate *NONNULL_PTR update);
30992 export function ChannelConfig_apply(this_arg: bigint, update: bigint): void {
30993 if(!isWasmInitialized) {
30994 throw new Error("initializeWasm() must be awaited first!");
30996 const nativeResponseValue = wasm.TS_ChannelConfig_apply(this_arg, update);
30997 // debug statements here
30999 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
31001 export function ChannelConfig_default(): bigint {
31002 if(!isWasmInitialized) {
31003 throw new Error("initializeWasm() must be awaited first!");
31005 const nativeResponseValue = wasm.TS_ChannelConfig_default();
31006 return nativeResponseValue;
31008 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
31010 export function ChannelConfig_write(obj: bigint): number {
31011 if(!isWasmInitialized) {
31012 throw new Error("initializeWasm() must be awaited first!");
31014 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
31015 return nativeResponseValue;
31017 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
31019 export function ChannelConfig_read(ser: number): bigint {
31020 if(!isWasmInitialized) {
31021 throw new Error("initializeWasm() must be awaited first!");
31023 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
31024 return nativeResponseValue;
31026 // void ChannelConfigUpdate_free(struct LDKChannelConfigUpdate this_obj);
31028 export function ChannelConfigUpdate_free(this_obj: bigint): void {
31029 if(!isWasmInitialized) {
31030 throw new Error("initializeWasm() must be awaited first!");
31032 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_free(this_obj);
31033 // debug statements here
31035 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
31037 export function ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr: bigint): bigint {
31038 if(!isWasmInitialized) {
31039 throw new Error("initializeWasm() must be awaited first!");
31041 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr);
31042 return nativeResponseValue;
31044 // void ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
31046 export function ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: bigint): void {
31047 if(!isWasmInitialized) {
31048 throw new Error("initializeWasm() must be awaited first!");
31050 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr, val);
31051 // debug statements here
31053 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_base_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
31055 export function ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr: bigint): bigint {
31056 if(!isWasmInitialized) {
31057 throw new Error("initializeWasm() must be awaited first!");
31059 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr);
31060 return nativeResponseValue;
31062 // void ChannelConfigUpdate_set_forwarding_fee_base_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
31064 export function ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr: bigint, val: bigint): void {
31065 if(!isWasmInitialized) {
31066 throw new Error("initializeWasm() must be awaited first!");
31068 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr, val);
31069 // debug statements here
31071 // struct LDKCOption_u16Z ChannelConfigUpdate_get_cltv_expiry_delta(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
31073 export function ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr: bigint): bigint {
31074 if(!isWasmInitialized) {
31075 throw new Error("initializeWasm() must be awaited first!");
31077 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr);
31078 return nativeResponseValue;
31080 // void ChannelConfigUpdate_set_cltv_expiry_delta(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
31082 export function ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: bigint): void {
31083 if(!isWasmInitialized) {
31084 throw new Error("initializeWasm() must be awaited first!");
31086 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr, val);
31087 // debug statements here
31089 // struct LDKCOption_MaxDustHTLCExposureZ ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
31091 export function ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
31092 if(!isWasmInitialized) {
31093 throw new Error("initializeWasm() must be awaited first!");
31095 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr);
31096 return nativeResponseValue;
31098 // void ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_MaxDustHTLCExposureZ val);
31100 export function ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
31101 if(!isWasmInitialized) {
31102 throw new Error("initializeWasm() must be awaited first!");
31104 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr, val);
31105 // debug statements here
31107 // struct LDKCOption_u64Z ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
31109 export function ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
31110 if(!isWasmInitialized) {
31111 throw new Error("initializeWasm() must be awaited first!");
31113 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr);
31114 return nativeResponseValue;
31116 // void ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31118 export function ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
31119 if(!isWasmInitialized) {
31120 throw new Error("initializeWasm() must be awaited first!");
31122 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
31123 // debug statements here
31125 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_new(struct LDKCOption_u32Z forwarding_fee_proportional_millionths_arg, struct LDKCOption_u32Z forwarding_fee_base_msat_arg, struct LDKCOption_u16Z cltv_expiry_delta_arg, struct LDKCOption_MaxDustHTLCExposureZ max_dust_htlc_exposure_msat_arg, struct LDKCOption_u64Z force_close_avoidance_max_fee_satoshis_arg);
31127 export function ChannelConfigUpdate_new(forwarding_fee_proportional_millionths_arg: bigint, forwarding_fee_base_msat_arg: bigint, cltv_expiry_delta_arg: bigint, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): bigint {
31128 if(!isWasmInitialized) {
31129 throw new Error("initializeWasm() must be awaited first!");
31131 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_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);
31132 return nativeResponseValue;
31134 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_default(void);
31136 export function ChannelConfigUpdate_default(): bigint {
31137 if(!isWasmInitialized) {
31138 throw new Error("initializeWasm() must be awaited first!");
31140 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_default();
31141 return nativeResponseValue;
31143 // void UserConfig_free(struct LDKUserConfig this_obj);
31145 export function UserConfig_free(this_obj: bigint): void {
31146 if(!isWasmInitialized) {
31147 throw new Error("initializeWasm() must be awaited first!");
31149 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
31150 // debug statements here
31152 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31154 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
31155 if(!isWasmInitialized) {
31156 throw new Error("initializeWasm() must be awaited first!");
31158 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
31159 return nativeResponseValue;
31161 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
31163 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
31164 if(!isWasmInitialized) {
31165 throw new Error("initializeWasm() must be awaited first!");
31167 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
31168 // debug statements here
31170 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31172 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
31173 if(!isWasmInitialized) {
31174 throw new Error("initializeWasm() must be awaited first!");
31176 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
31177 return nativeResponseValue;
31179 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
31181 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
31182 if(!isWasmInitialized) {
31183 throw new Error("initializeWasm() must be awaited first!");
31185 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
31186 // debug statements here
31188 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31190 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
31191 if(!isWasmInitialized) {
31192 throw new Error("initializeWasm() must be awaited first!");
31194 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
31195 return nativeResponseValue;
31197 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
31199 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
31200 if(!isWasmInitialized) {
31201 throw new Error("initializeWasm() must be awaited first!");
31203 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
31204 // debug statements here
31206 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31208 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
31209 if(!isWasmInitialized) {
31210 throw new Error("initializeWasm() must be awaited first!");
31212 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
31213 return nativeResponseValue;
31215 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
31217 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
31218 if(!isWasmInitialized) {
31219 throw new Error("initializeWasm() must be awaited first!");
31221 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
31222 // debug statements here
31224 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31226 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
31227 if(!isWasmInitialized) {
31228 throw new Error("initializeWasm() must be awaited first!");
31230 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
31231 return nativeResponseValue;
31233 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
31235 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
31236 if(!isWasmInitialized) {
31237 throw new Error("initializeWasm() must be awaited first!");
31239 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
31240 // debug statements here
31242 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31244 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
31245 if(!isWasmInitialized) {
31246 throw new Error("initializeWasm() must be awaited first!");
31248 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
31249 return nativeResponseValue;
31251 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
31253 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
31254 if(!isWasmInitialized) {
31255 throw new Error("initializeWasm() must be awaited first!");
31257 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
31258 // debug statements here
31260 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31262 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
31263 if(!isWasmInitialized) {
31264 throw new Error("initializeWasm() must be awaited first!");
31266 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
31267 return nativeResponseValue;
31269 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
31271 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
31272 if(!isWasmInitialized) {
31273 throw new Error("initializeWasm() must be awaited first!");
31275 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
31276 // debug statements here
31278 // bool UserConfig_get_accept_mpp_keysend(const struct LDKUserConfig *NONNULL_PTR this_ptr);
31280 export function UserConfig_get_accept_mpp_keysend(this_ptr: bigint): boolean {
31281 if(!isWasmInitialized) {
31282 throw new Error("initializeWasm() must be awaited first!");
31284 const nativeResponseValue = wasm.TS_UserConfig_get_accept_mpp_keysend(this_ptr);
31285 return nativeResponseValue;
31287 // void UserConfig_set_accept_mpp_keysend(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
31289 export function UserConfig_set_accept_mpp_keysend(this_ptr: bigint, val: boolean): void {
31290 if(!isWasmInitialized) {
31291 throw new Error("initializeWasm() must be awaited first!");
31293 const nativeResponseValue = wasm.TS_UserConfig_set_accept_mpp_keysend(this_ptr, val);
31294 // debug statements here
31296 // 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, bool accept_mpp_keysend_arg);
31298 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, accept_mpp_keysend_arg: boolean): bigint {
31299 if(!isWasmInitialized) {
31300 throw new Error("initializeWasm() must be awaited first!");
31302 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, accept_mpp_keysend_arg);
31303 return nativeResponseValue;
31305 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
31307 export function UserConfig_clone_ptr(arg: bigint): bigint {
31308 if(!isWasmInitialized) {
31309 throw new Error("initializeWasm() must be awaited first!");
31311 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
31312 return nativeResponseValue;
31314 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
31316 export function UserConfig_clone(orig: bigint): bigint {
31317 if(!isWasmInitialized) {
31318 throw new Error("initializeWasm() must be awaited first!");
31320 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
31321 return nativeResponseValue;
31323 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
31325 export function UserConfig_default(): bigint {
31326 if(!isWasmInitialized) {
31327 throw new Error("initializeWasm() must be awaited first!");
31329 const nativeResponseValue = wasm.TS_UserConfig_default();
31330 return nativeResponseValue;
31332 // void BestBlock_free(struct LDKBestBlock this_obj);
31334 export function BestBlock_free(this_obj: bigint): void {
31335 if(!isWasmInitialized) {
31336 throw new Error("initializeWasm() must be awaited first!");
31338 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
31339 // debug statements here
31341 // const uint8_t (*BestBlock_get_block_hash(const struct LDKBestBlock *NONNULL_PTR this_ptr))[32];
31343 export function BestBlock_get_block_hash(this_ptr: bigint): number {
31344 if(!isWasmInitialized) {
31345 throw new Error("initializeWasm() must be awaited first!");
31347 const nativeResponseValue = wasm.TS_BestBlock_get_block_hash(this_ptr);
31348 return nativeResponseValue;
31350 // void BestBlock_set_block_hash(struct LDKBestBlock *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31352 export function BestBlock_set_block_hash(this_ptr: bigint, val: number): void {
31353 if(!isWasmInitialized) {
31354 throw new Error("initializeWasm() must be awaited first!");
31356 const nativeResponseValue = wasm.TS_BestBlock_set_block_hash(this_ptr, val);
31357 // debug statements here
31359 // uint32_t BestBlock_get_height(const struct LDKBestBlock *NONNULL_PTR this_ptr);
31361 export function BestBlock_get_height(this_ptr: bigint): number {
31362 if(!isWasmInitialized) {
31363 throw new Error("initializeWasm() must be awaited first!");
31365 const nativeResponseValue = wasm.TS_BestBlock_get_height(this_ptr);
31366 return nativeResponseValue;
31368 // void BestBlock_set_height(struct LDKBestBlock *NONNULL_PTR this_ptr, uint32_t val);
31370 export function BestBlock_set_height(this_ptr: bigint, val: number): void {
31371 if(!isWasmInitialized) {
31372 throw new Error("initializeWasm() must be awaited first!");
31374 const nativeResponseValue = wasm.TS_BestBlock_set_height(this_ptr, val);
31375 // debug statements here
31377 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash_arg, uint32_t height_arg);
31379 export function BestBlock_new(block_hash_arg: number, height_arg: number): bigint {
31380 if(!isWasmInitialized) {
31381 throw new Error("initializeWasm() must be awaited first!");
31383 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash_arg, height_arg);
31384 return nativeResponseValue;
31386 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
31388 export function BestBlock_clone_ptr(arg: bigint): bigint {
31389 if(!isWasmInitialized) {
31390 throw new Error("initializeWasm() must be awaited first!");
31392 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
31393 return nativeResponseValue;
31395 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
31397 export function BestBlock_clone(orig: bigint): bigint {
31398 if(!isWasmInitialized) {
31399 throw new Error("initializeWasm() must be awaited first!");
31401 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
31402 return nativeResponseValue;
31404 // uint64_t BestBlock_hash(const struct LDKBestBlock *NONNULL_PTR o);
31406 export function BestBlock_hash(o: bigint): bigint {
31407 if(!isWasmInitialized) {
31408 throw new Error("initializeWasm() must be awaited first!");
31410 const nativeResponseValue = wasm.TS_BestBlock_hash(o);
31411 return nativeResponseValue;
31413 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
31415 export function BestBlock_eq(a: bigint, b: bigint): boolean {
31416 if(!isWasmInitialized) {
31417 throw new Error("initializeWasm() must be awaited first!");
31419 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
31420 return nativeResponseValue;
31422 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
31424 export function BestBlock_from_network(network: Network): bigint {
31425 if(!isWasmInitialized) {
31426 throw new Error("initializeWasm() must be awaited first!");
31428 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
31429 return nativeResponseValue;
31431 // struct LDKCVec_u8Z BestBlock_write(const struct LDKBestBlock *NONNULL_PTR obj);
31433 export function BestBlock_write(obj: bigint): number {
31434 if(!isWasmInitialized) {
31435 throw new Error("initializeWasm() must be awaited first!");
31437 const nativeResponseValue = wasm.TS_BestBlock_write(obj);
31438 return nativeResponseValue;
31440 // struct LDKCResult_BestBlockDecodeErrorZ BestBlock_read(struct LDKu8slice ser);
31442 export function BestBlock_read(ser: number): bigint {
31443 if(!isWasmInitialized) {
31444 throw new Error("initializeWasm() must be awaited first!");
31446 const nativeResponseValue = wasm.TS_BestBlock_read(ser);
31447 return nativeResponseValue;
31449 // void Listen_free(struct LDKListen this_ptr);
31451 export function Listen_free(this_ptr: bigint): void {
31452 if(!isWasmInitialized) {
31453 throw new Error("initializeWasm() must be awaited first!");
31455 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
31456 // debug statements here
31458 // void Confirm_free(struct LDKConfirm this_ptr);
31460 export function Confirm_free(this_ptr: bigint): void {
31461 if(!isWasmInitialized) {
31462 throw new Error("initializeWasm() must be awaited first!");
31464 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
31465 // debug statements here
31467 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
31469 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
31470 if(!isWasmInitialized) {
31471 throw new Error("initializeWasm() must be awaited first!");
31473 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
31474 return nativeResponseValue;
31476 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
31478 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
31479 if(!isWasmInitialized) {
31480 throw new Error("initializeWasm() must be awaited first!");
31482 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
31483 return nativeResponseValue;
31485 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
31487 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
31488 if(!isWasmInitialized) {
31489 throw new Error("initializeWasm() must be awaited first!");
31491 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
31492 return nativeResponseValue;
31494 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_unrecoverable_error(void);
31496 export function ChannelMonitorUpdateStatus_unrecoverable_error(): ChannelMonitorUpdateStatus {
31497 if(!isWasmInitialized) {
31498 throw new Error("initializeWasm() must be awaited first!");
31500 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_unrecoverable_error();
31501 return nativeResponseValue;
31503 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
31505 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
31506 if(!isWasmInitialized) {
31507 throw new Error("initializeWasm() must be awaited first!");
31509 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
31510 return nativeResponseValue;
31512 // void Watch_free(struct LDKWatch this_ptr);
31514 export function Watch_free(this_ptr: bigint): void {
31515 if(!isWasmInitialized) {
31516 throw new Error("initializeWasm() must be awaited first!");
31518 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
31519 // debug statements here
31521 // void Filter_free(struct LDKFilter this_ptr);
31523 export function Filter_free(this_ptr: bigint): void {
31524 if(!isWasmInitialized) {
31525 throw new Error("initializeWasm() must be awaited first!");
31527 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
31528 // debug statements here
31530 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
31532 export function WatchedOutput_free(this_obj: bigint): void {
31533 if(!isWasmInitialized) {
31534 throw new Error("initializeWasm() must be awaited first!");
31536 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
31537 // debug statements here
31539 // struct LDKCOption_ThirtyTwoBytesZ WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
31541 export function WatchedOutput_get_block_hash(this_ptr: bigint): bigint {
31542 if(!isWasmInitialized) {
31543 throw new Error("initializeWasm() must be awaited first!");
31545 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
31546 return nativeResponseValue;
31548 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
31550 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: bigint): void {
31551 if(!isWasmInitialized) {
31552 throw new Error("initializeWasm() must be awaited first!");
31554 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
31555 // debug statements here
31557 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
31559 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
31560 if(!isWasmInitialized) {
31561 throw new Error("initializeWasm() must be awaited first!");
31563 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
31564 return nativeResponseValue;
31566 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
31568 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
31569 if(!isWasmInitialized) {
31570 throw new Error("initializeWasm() must be awaited first!");
31572 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
31573 // debug statements here
31575 // struct LDKCVec_u8Z WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
31577 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
31578 if(!isWasmInitialized) {
31579 throw new Error("initializeWasm() must be awaited first!");
31581 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
31582 return nativeResponseValue;
31584 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
31586 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
31587 if(!isWasmInitialized) {
31588 throw new Error("initializeWasm() must be awaited first!");
31590 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
31591 // debug statements here
31593 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKCOption_ThirtyTwoBytesZ block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
31595 export function WatchedOutput_new(block_hash_arg: bigint, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
31596 if(!isWasmInitialized) {
31597 throw new Error("initializeWasm() must be awaited first!");
31599 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
31600 return nativeResponseValue;
31602 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
31604 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
31605 if(!isWasmInitialized) {
31606 throw new Error("initializeWasm() must be awaited first!");
31608 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
31609 return nativeResponseValue;
31611 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
31613 export function WatchedOutput_clone(orig: bigint): bigint {
31614 if(!isWasmInitialized) {
31615 throw new Error("initializeWasm() must be awaited first!");
31617 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
31618 return nativeResponseValue;
31620 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
31622 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
31623 if(!isWasmInitialized) {
31624 throw new Error("initializeWasm() must be awaited first!");
31626 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
31627 return nativeResponseValue;
31629 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
31631 export function WatchedOutput_hash(o: bigint): bigint {
31632 if(!isWasmInitialized) {
31633 throw new Error("initializeWasm() must be awaited first!");
31635 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
31636 return nativeResponseValue;
31638 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
31640 export function BroadcasterInterface_free(this_ptr: bigint): void {
31641 if(!isWasmInitialized) {
31642 throw new Error("initializeWasm() must be awaited first!");
31644 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
31645 // debug statements here
31647 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
31649 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
31650 if(!isWasmInitialized) {
31651 throw new Error("initializeWasm() must be awaited first!");
31653 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
31654 return nativeResponseValue;
31656 // enum LDKConfirmationTarget ConfirmationTarget_on_chain_sweep(void);
31658 export function ConfirmationTarget_on_chain_sweep(): ConfirmationTarget {
31659 if(!isWasmInitialized) {
31660 throw new Error("initializeWasm() must be awaited first!");
31662 const nativeResponseValue = wasm.TS_ConfirmationTarget_on_chain_sweep();
31663 return nativeResponseValue;
31665 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_anchor_channel_remote_fee(void);
31667 export function ConfirmationTarget_min_allowed_anchor_channel_remote_fee(): ConfirmationTarget {
31668 if(!isWasmInitialized) {
31669 throw new Error("initializeWasm() must be awaited first!");
31671 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_anchor_channel_remote_fee();
31672 return nativeResponseValue;
31674 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(void);
31676 export function ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(): ConfirmationTarget {
31677 if(!isWasmInitialized) {
31678 throw new Error("initializeWasm() must be awaited first!");
31680 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee();
31681 return nativeResponseValue;
31683 // enum LDKConfirmationTarget ConfirmationTarget_anchor_channel_fee(void);
31685 export function ConfirmationTarget_anchor_channel_fee(): ConfirmationTarget {
31686 if(!isWasmInitialized) {
31687 throw new Error("initializeWasm() must be awaited first!");
31689 const nativeResponseValue = wasm.TS_ConfirmationTarget_anchor_channel_fee();
31690 return nativeResponseValue;
31692 // enum LDKConfirmationTarget ConfirmationTarget_non_anchor_channel_fee(void);
31694 export function ConfirmationTarget_non_anchor_channel_fee(): ConfirmationTarget {
31695 if(!isWasmInitialized) {
31696 throw new Error("initializeWasm() must be awaited first!");
31698 const nativeResponseValue = wasm.TS_ConfirmationTarget_non_anchor_channel_fee();
31699 return nativeResponseValue;
31701 // enum LDKConfirmationTarget ConfirmationTarget_channel_close_minimum(void);
31703 export function ConfirmationTarget_channel_close_minimum(): ConfirmationTarget {
31704 if(!isWasmInitialized) {
31705 throw new Error("initializeWasm() must be awaited first!");
31707 const nativeResponseValue = wasm.TS_ConfirmationTarget_channel_close_minimum();
31708 return nativeResponseValue;
31710 // enum LDKConfirmationTarget ConfirmationTarget_output_spending_fee(void);
31712 export function ConfirmationTarget_output_spending_fee(): ConfirmationTarget {
31713 if(!isWasmInitialized) {
31714 throw new Error("initializeWasm() must be awaited first!");
31716 const nativeResponseValue = wasm.TS_ConfirmationTarget_output_spending_fee();
31717 return nativeResponseValue;
31719 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
31721 export function ConfirmationTarget_hash(o: bigint): bigint {
31722 if(!isWasmInitialized) {
31723 throw new Error("initializeWasm() must be awaited first!");
31725 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
31726 return nativeResponseValue;
31728 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
31730 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
31731 if(!isWasmInitialized) {
31732 throw new Error("initializeWasm() must be awaited first!");
31734 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
31735 return nativeResponseValue;
31737 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
31739 export function FeeEstimator_free(this_ptr: bigint): void {
31740 if(!isWasmInitialized) {
31741 throw new Error("initializeWasm() must be awaited first!");
31743 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
31744 // debug statements here
31746 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
31748 export function MonitorUpdateId_free(this_obj: bigint): void {
31749 if(!isWasmInitialized) {
31750 throw new Error("initializeWasm() must be awaited first!");
31752 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
31753 // debug statements here
31755 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
31757 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
31758 if(!isWasmInitialized) {
31759 throw new Error("initializeWasm() must be awaited first!");
31761 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
31762 return nativeResponseValue;
31764 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
31766 export function MonitorUpdateId_clone(orig: bigint): bigint {
31767 if(!isWasmInitialized) {
31768 throw new Error("initializeWasm() must be awaited first!");
31770 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
31771 return nativeResponseValue;
31773 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
31775 export function MonitorUpdateId_hash(o: bigint): bigint {
31776 if(!isWasmInitialized) {
31777 throw new Error("initializeWasm() must be awaited first!");
31779 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
31780 return nativeResponseValue;
31782 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
31784 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
31785 if(!isWasmInitialized) {
31786 throw new Error("initializeWasm() must be awaited first!");
31788 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
31789 return nativeResponseValue;
31791 // void Persist_free(struct LDKPersist this_ptr);
31793 export function Persist_free(this_ptr: bigint): void {
31794 if(!isWasmInitialized) {
31795 throw new Error("initializeWasm() must be awaited first!");
31797 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
31798 // debug statements here
31800 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
31802 export function LockedChannelMonitor_free(this_obj: bigint): void {
31803 if(!isWasmInitialized) {
31804 throw new Error("initializeWasm() must be awaited first!");
31806 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
31807 // debug statements here
31809 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
31811 export function ChainMonitor_free(this_obj: bigint): void {
31812 if(!isWasmInitialized) {
31813 throw new Error("initializeWasm() must be awaited first!");
31815 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
31816 // debug statements here
31818 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
31820 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
31821 if(!isWasmInitialized) {
31822 throw new Error("initializeWasm() must be awaited first!");
31824 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
31825 return nativeResponseValue;
31827 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
31829 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
31830 if(!isWasmInitialized) {
31831 throw new Error("initializeWasm() must be awaited first!");
31833 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
31834 return nativeResponseValue;
31836 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
31838 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
31839 if(!isWasmInitialized) {
31840 throw new Error("initializeWasm() must be awaited first!");
31842 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
31843 return nativeResponseValue;
31845 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointChannelIdZZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31847 export function ChainMonitor_list_monitors(this_arg: bigint): number {
31848 if(!isWasmInitialized) {
31849 throw new Error("initializeWasm() must be awaited first!");
31851 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
31852 return nativeResponseValue;
31854 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31856 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
31857 if(!isWasmInitialized) {
31858 throw new Error("initializeWasm() must be awaited first!");
31860 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
31861 return nativeResponseValue;
31863 // 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);
31865 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
31866 if(!isWasmInitialized) {
31867 throw new Error("initializeWasm() must be awaited first!");
31869 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
31870 return nativeResponseValue;
31872 // MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31874 export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
31875 if(!isWasmInitialized) {
31876 throw new Error("initializeWasm() must be awaited first!");
31878 const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
31879 return nativeResponseValue;
31881 // void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31883 export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
31884 if(!isWasmInitialized) {
31885 throw new Error("initializeWasm() must be awaited first!");
31887 const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
31888 // debug statements here
31890 // void ChainMonitor_signer_unblocked(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint monitor_opt);
31892 export function ChainMonitor_signer_unblocked(this_arg: bigint, monitor_opt: bigint): void {
31893 if(!isWasmInitialized) {
31894 throw new Error("initializeWasm() must be awaited first!");
31896 const nativeResponseValue = wasm.TS_ChainMonitor_signer_unblocked(this_arg, monitor_opt);
31897 // debug statements here
31899 // void ChainMonitor_archive_fully_resolved_channel_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31901 export function ChainMonitor_archive_fully_resolved_channel_monitors(this_arg: bigint): void {
31902 if(!isWasmInitialized) {
31903 throw new Error("initializeWasm() must be awaited first!");
31905 const nativeResponseValue = wasm.TS_ChainMonitor_archive_fully_resolved_channel_monitors(this_arg);
31906 // debug statements here
31908 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31910 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
31911 if(!isWasmInitialized) {
31912 throw new Error("initializeWasm() must be awaited first!");
31914 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
31915 return nativeResponseValue;
31917 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31919 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
31920 if(!isWasmInitialized) {
31921 throw new Error("initializeWasm() must be awaited first!");
31923 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
31924 return nativeResponseValue;
31926 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31928 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
31929 if(!isWasmInitialized) {
31930 throw new Error("initializeWasm() must be awaited first!");
31932 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
31933 return nativeResponseValue;
31935 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
31937 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
31938 if(!isWasmInitialized) {
31939 throw new Error("initializeWasm() must be awaited first!");
31941 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
31942 return nativeResponseValue;
31944 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
31946 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
31947 if(!isWasmInitialized) {
31948 throw new Error("initializeWasm() must be awaited first!");
31950 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
31951 // debug statements here
31953 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
31955 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
31956 if(!isWasmInitialized) {
31957 throw new Error("initializeWasm() must be awaited first!");
31959 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
31960 return nativeResponseValue;
31962 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
31964 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
31965 if(!isWasmInitialized) {
31966 throw new Error("initializeWasm() must be awaited first!");
31968 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
31969 // debug statements here
31971 // struct LDKChannelId ChannelMonitorUpdate_get_channel_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
31973 export function ChannelMonitorUpdate_get_channel_id(this_ptr: bigint): bigint {
31974 if(!isWasmInitialized) {
31975 throw new Error("initializeWasm() must be awaited first!");
31977 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_channel_id(this_ptr);
31978 return nativeResponseValue;
31980 // void ChannelMonitorUpdate_set_channel_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, struct LDKChannelId val);
31982 export function ChannelMonitorUpdate_set_channel_id(this_ptr: bigint, val: bigint): void {
31983 if(!isWasmInitialized) {
31984 throw new Error("initializeWasm() must be awaited first!");
31986 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_channel_id(this_ptr, val);
31987 // debug statements here
31989 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
31991 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
31992 if(!isWasmInitialized) {
31993 throw new Error("initializeWasm() must be awaited first!");
31995 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
31996 return nativeResponseValue;
31998 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
32000 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
32001 if(!isWasmInitialized) {
32002 throw new Error("initializeWasm() must be awaited first!");
32004 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
32005 return nativeResponseValue;
32007 // bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
32009 export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
32010 if(!isWasmInitialized) {
32011 throw new Error("initializeWasm() must be awaited first!");
32013 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
32014 return nativeResponseValue;
32016 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
32018 export function ChannelMonitorUpdate_write(obj: bigint): number {
32019 if(!isWasmInitialized) {
32020 throw new Error("initializeWasm() must be awaited first!");
32022 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
32023 return nativeResponseValue;
32025 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
32027 export function ChannelMonitorUpdate_read(ser: number): bigint {
32028 if(!isWasmInitialized) {
32029 throw new Error("initializeWasm() must be awaited first!");
32031 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
32032 return nativeResponseValue;
32034 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
32036 export function MonitorEvent_free(this_ptr: bigint): void {
32037 if(!isWasmInitialized) {
32038 throw new Error("initializeWasm() must be awaited first!");
32040 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
32041 // debug statements here
32043 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
32045 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
32046 if(!isWasmInitialized) {
32047 throw new Error("initializeWasm() must be awaited first!");
32049 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
32050 return nativeResponseValue;
32052 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
32054 export function MonitorEvent_clone(orig: bigint): bigint {
32055 if(!isWasmInitialized) {
32056 throw new Error("initializeWasm() must be awaited first!");
32058 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
32059 return nativeResponseValue;
32061 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
32063 export function MonitorEvent_htlcevent(a: bigint): bigint {
32064 if(!isWasmInitialized) {
32065 throw new Error("initializeWasm() must be awaited first!");
32067 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
32068 return nativeResponseValue;
32070 // struct LDKMonitorEvent MonitorEvent_holder_force_closed_with_info(struct LDKClosureReason reason, struct LDKOutPoint outpoint, struct LDKChannelId channel_id);
32072 export function MonitorEvent_holder_force_closed_with_info(reason: bigint, outpoint: bigint, channel_id: bigint): bigint {
32073 if(!isWasmInitialized) {
32074 throw new Error("initializeWasm() must be awaited first!");
32076 const nativeResponseValue = wasm.TS_MonitorEvent_holder_force_closed_with_info(reason, outpoint, channel_id);
32077 return nativeResponseValue;
32079 // struct LDKMonitorEvent MonitorEvent_holder_force_closed(struct LDKOutPoint a);
32081 export function MonitorEvent_holder_force_closed(a: bigint): bigint {
32082 if(!isWasmInitialized) {
32083 throw new Error("initializeWasm() must be awaited first!");
32085 const nativeResponseValue = wasm.TS_MonitorEvent_holder_force_closed(a);
32086 return nativeResponseValue;
32088 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, struct LDKChannelId channel_id, uint64_t monitor_update_id);
32090 export function MonitorEvent_completed(funding_txo: bigint, channel_id: bigint, monitor_update_id: bigint): bigint {
32091 if(!isWasmInitialized) {
32092 throw new Error("initializeWasm() must be awaited first!");
32094 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, channel_id, monitor_update_id);
32095 return nativeResponseValue;
32097 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
32099 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
32100 if(!isWasmInitialized) {
32101 throw new Error("initializeWasm() must be awaited first!");
32103 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
32104 return nativeResponseValue;
32106 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
32108 export function MonitorEvent_write(obj: bigint): number {
32109 if(!isWasmInitialized) {
32110 throw new Error("initializeWasm() must be awaited first!");
32112 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
32113 return nativeResponseValue;
32115 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
32117 export function MonitorEvent_read(ser: number): bigint {
32118 if(!isWasmInitialized) {
32119 throw new Error("initializeWasm() must be awaited first!");
32121 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
32122 return nativeResponseValue;
32124 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
32126 export function HTLCUpdate_free(this_obj: bigint): void {
32127 if(!isWasmInitialized) {
32128 throw new Error("initializeWasm() must be awaited first!");
32130 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
32131 // debug statements here
32133 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
32135 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
32136 if(!isWasmInitialized) {
32137 throw new Error("initializeWasm() must be awaited first!");
32139 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
32140 return nativeResponseValue;
32142 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
32144 export function HTLCUpdate_clone(orig: bigint): bigint {
32145 if(!isWasmInitialized) {
32146 throw new Error("initializeWasm() must be awaited first!");
32148 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
32149 return nativeResponseValue;
32151 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
32153 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
32154 if(!isWasmInitialized) {
32155 throw new Error("initializeWasm() must be awaited first!");
32157 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
32158 return nativeResponseValue;
32160 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
32162 export function HTLCUpdate_write(obj: bigint): number {
32163 if(!isWasmInitialized) {
32164 throw new Error("initializeWasm() must be awaited first!");
32166 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
32167 return nativeResponseValue;
32169 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
32171 export function HTLCUpdate_read(ser: number): bigint {
32172 if(!isWasmInitialized) {
32173 throw new Error("initializeWasm() must be awaited first!");
32175 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
32176 return nativeResponseValue;
32178 // void Balance_free(struct LDKBalance this_ptr);
32180 export function Balance_free(this_ptr: bigint): void {
32181 if(!isWasmInitialized) {
32182 throw new Error("initializeWasm() must be awaited first!");
32184 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
32185 // debug statements here
32187 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
32189 export function Balance_clone_ptr(arg: bigint): bigint {
32190 if(!isWasmInitialized) {
32191 throw new Error("initializeWasm() must be awaited first!");
32193 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
32194 return nativeResponseValue;
32196 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
32198 export function Balance_clone(orig: bigint): bigint {
32199 if(!isWasmInitialized) {
32200 throw new Error("initializeWasm() must be awaited first!");
32202 const nativeResponseValue = wasm.TS_Balance_clone(orig);
32203 return nativeResponseValue;
32205 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t amount_satoshis);
32207 export function Balance_claimable_on_channel_close(amount_satoshis: bigint): bigint {
32208 if(!isWasmInitialized) {
32209 throw new Error("initializeWasm() must be awaited first!");
32211 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(amount_satoshis);
32212 return nativeResponseValue;
32214 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t amount_satoshis, uint32_t confirmation_height);
32216 export function Balance_claimable_awaiting_confirmations(amount_satoshis: bigint, confirmation_height: number): bigint {
32217 if(!isWasmInitialized) {
32218 throw new Error("initializeWasm() must be awaited first!");
32220 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
32221 return nativeResponseValue;
32223 // struct LDKBalance Balance_contentious_claimable(uint64_t amount_satoshis, uint32_t timeout_height, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage);
32225 export function Balance_contentious_claimable(amount_satoshis: bigint, timeout_height: number, payment_hash: number, payment_preimage: number): bigint {
32226 if(!isWasmInitialized) {
32227 throw new Error("initializeWasm() must be awaited first!");
32229 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash, payment_preimage);
32230 return nativeResponseValue;
32232 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t amount_satoshis, uint32_t claimable_height, struct LDKThirtyTwoBytes payment_hash);
32234 export function Balance_maybe_timeout_claimable_htlc(amount_satoshis: bigint, claimable_height: number, payment_hash: number): bigint {
32235 if(!isWasmInitialized) {
32236 throw new Error("initializeWasm() must be awaited first!");
32238 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash);
32239 return nativeResponseValue;
32241 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t amount_satoshis, uint32_t expiry_height, struct LDKThirtyTwoBytes payment_hash);
32243 export function Balance_maybe_preimage_claimable_htlc(amount_satoshis: bigint, expiry_height: number, payment_hash: number): bigint {
32244 if(!isWasmInitialized) {
32245 throw new Error("initializeWasm() must be awaited first!");
32247 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash);
32248 return nativeResponseValue;
32250 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t amount_satoshis);
32252 export function Balance_counterparty_revoked_output_claimable(amount_satoshis: bigint): bigint {
32253 if(!isWasmInitialized) {
32254 throw new Error("initializeWasm() must be awaited first!");
32256 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(amount_satoshis);
32257 return nativeResponseValue;
32259 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
32261 export function Balance_eq(a: bigint, b: bigint): boolean {
32262 if(!isWasmInitialized) {
32263 throw new Error("initializeWasm() must be awaited first!");
32265 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
32266 return nativeResponseValue;
32268 // MUST_USE_RES uint64_t Balance_claimable_amount_satoshis(const struct LDKBalance *NONNULL_PTR this_arg);
32270 export function Balance_claimable_amount_satoshis(this_arg: bigint): bigint {
32271 if(!isWasmInitialized) {
32272 throw new Error("initializeWasm() must be awaited first!");
32274 const nativeResponseValue = wasm.TS_Balance_claimable_amount_satoshis(this_arg);
32275 return nativeResponseValue;
32277 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
32279 export function ChannelMonitor_free(this_obj: bigint): void {
32280 if(!isWasmInitialized) {
32281 throw new Error("initializeWasm() must be awaited first!");
32283 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
32284 // debug statements here
32286 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
32288 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
32289 if(!isWasmInitialized) {
32290 throw new Error("initializeWasm() must be awaited first!");
32292 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
32293 return nativeResponseValue;
32295 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
32297 export function ChannelMonitor_clone(orig: bigint): bigint {
32298 if(!isWasmInitialized) {
32299 throw new Error("initializeWasm() must be awaited first!");
32301 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
32302 return nativeResponseValue;
32304 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
32306 export function ChannelMonitor_write(obj: bigint): number {
32307 if(!isWasmInitialized) {
32308 throw new Error("initializeWasm() must be awaited first!");
32310 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
32311 return nativeResponseValue;
32313 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
32315 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
32316 if(!isWasmInitialized) {
32317 throw new Error("initializeWasm() must be awaited first!");
32319 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
32320 return nativeResponseValue;
32322 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32324 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
32325 if(!isWasmInitialized) {
32326 throw new Error("initializeWasm() must be awaited first!");
32328 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
32329 return nativeResponseValue;
32331 // MUST_USE_RES struct LDKC2Tuple_OutPointCVec_u8ZZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32333 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
32334 if(!isWasmInitialized) {
32335 throw new Error("initializeWasm() must be awaited first!");
32337 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
32338 return nativeResponseValue;
32340 // MUST_USE_RES struct LDKChannelId ChannelMonitor_channel_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32342 export function ChannelMonitor_channel_id(this_arg: bigint): bigint {
32343 if(!isWasmInitialized) {
32344 throw new Error("initializeWasm() must be awaited first!");
32346 const nativeResponseValue = wasm.TS_ChannelMonitor_channel_id(this_arg);
32347 return nativeResponseValue;
32349 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32351 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
32352 if(!isWasmInitialized) {
32353 throw new Error("initializeWasm() must be awaited first!");
32355 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
32356 return nativeResponseValue;
32358 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter, const struct LDKLogger *NONNULL_PTR logger);
32360 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint, logger: bigint): void {
32361 if(!isWasmInitialized) {
32362 throw new Error("initializeWasm() must be awaited first!");
32364 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter, logger);
32365 // debug statements here
32367 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32369 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
32370 if(!isWasmInitialized) {
32371 throw new Error("initializeWasm() must be awaited first!");
32373 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
32374 return nativeResponseValue;
32376 // void ChannelMonitor_process_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKEventHandler *NONNULL_PTR handler);
32378 export function ChannelMonitor_process_pending_events(this_arg: bigint, handler: bigint): void {
32379 if(!isWasmInitialized) {
32380 throw new Error("initializeWasm() must be awaited first!");
32382 const nativeResponseValue = wasm.TS_ChannelMonitor_process_pending_events(this_arg, handler);
32383 // debug statements here
32385 // MUST_USE_RES struct LDKCommitmentTransaction ChannelMonitor_initial_counterparty_commitment_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32387 export function ChannelMonitor_initial_counterparty_commitment_tx(this_arg: bigint): bigint {
32388 if(!isWasmInitialized) {
32389 throw new Error("initializeWasm() must be awaited first!");
32391 const nativeResponseValue = wasm.TS_ChannelMonitor_initial_counterparty_commitment_tx(this_arg);
32392 return nativeResponseValue;
32394 // MUST_USE_RES struct LDKCVec_CommitmentTransactionZ ChannelMonitor_counterparty_commitment_txs_from_update(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
32396 export function ChannelMonitor_counterparty_commitment_txs_from_update(this_arg: bigint, update: bigint): number {
32397 if(!isWasmInitialized) {
32398 throw new Error("initializeWasm() must be awaited first!");
32400 const nativeResponseValue = wasm.TS_ChannelMonitor_counterparty_commitment_txs_from_update(this_arg, update);
32401 return nativeResponseValue;
32403 // MUST_USE_RES struct LDKCResult_TransactionNoneZ ChannelMonitor_sign_to_local_justice_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input_idx, uint64_t value, uint64_t commitment_number);
32405 export function ChannelMonitor_sign_to_local_justice_tx(this_arg: bigint, justice_tx: number, input_idx: number, value: bigint, commitment_number: bigint): bigint {
32406 if(!isWasmInitialized) {
32407 throw new Error("initializeWasm() must be awaited first!");
32409 const nativeResponseValue = wasm.TS_ChannelMonitor_sign_to_local_justice_tx(this_arg, justice_tx, input_idx, value, commitment_number);
32410 return nativeResponseValue;
32412 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32414 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
32415 if(!isWasmInitialized) {
32416 throw new Error("initializeWasm() must be awaited first!");
32418 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
32419 return nativeResponseValue;
32421 // void ChannelMonitor_broadcast_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
32423 export function ChannelMonitor_broadcast_latest_holder_commitment_txn(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
32424 if(!isWasmInitialized) {
32425 throw new Error("initializeWasm() must be awaited first!");
32427 const nativeResponseValue = wasm.TS_ChannelMonitor_broadcast_latest_holder_commitment_txn(this_arg, broadcaster, fee_estimator, logger);
32428 // debug statements here
32430 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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, const struct LDKLogger *NONNULL_PTR logger);
32432 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
32433 if(!isWasmInitialized) {
32434 throw new Error("initializeWasm() must be awaited first!");
32436 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
32437 return nativeResponseValue;
32439 // 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, const struct LDKLogger *NONNULL_PTR logger);
32441 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
32442 if(!isWasmInitialized) {
32443 throw new Error("initializeWasm() must be awaited first!");
32445 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
32446 // debug statements here
32448 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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, const struct LDKLogger *NONNULL_PTR logger);
32450 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
32451 if(!isWasmInitialized) {
32452 throw new Error("initializeWasm() must be awaited first!");
32454 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
32455 return nativeResponseValue;
32457 // void ChannelMonitor_transaction_unconfirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
32459 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
32460 if(!isWasmInitialized) {
32461 throw new Error("initializeWasm() must be awaited first!");
32463 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
32464 // debug statements here
32466 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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, const struct LDKLogger *NONNULL_PTR logger);
32468 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
32469 if(!isWasmInitialized) {
32470 throw new Error("initializeWasm() must be awaited first!");
32472 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
32473 return nativeResponseValue;
32475 // MUST_USE_RES struct LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32477 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
32478 if(!isWasmInitialized) {
32479 throw new Error("initializeWasm() must be awaited first!");
32481 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
32482 return nativeResponseValue;
32484 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32486 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
32487 if(!isWasmInitialized) {
32488 throw new Error("initializeWasm() must be awaited first!");
32490 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
32491 return nativeResponseValue;
32493 // void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
32495 export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
32496 if(!isWasmInitialized) {
32497 throw new Error("initializeWasm() must be awaited first!");
32499 const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
32500 // debug statements here
32502 // void ChannelMonitor_signer_unblocked(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
32504 export function ChannelMonitor_signer_unblocked(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
32505 if(!isWasmInitialized) {
32506 throw new Error("initializeWasm() must be awaited first!");
32508 const nativeResponseValue = wasm.TS_ChannelMonitor_signer_unblocked(this_arg, broadcaster, fee_estimator, logger);
32509 // debug statements here
32511 // MUST_USE_RES struct LDKCVec_SpendableOutputDescriptorZ ChannelMonitor_get_spendable_outputs(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction tx, uint32_t confirmation_height);
32513 export function ChannelMonitor_get_spendable_outputs(this_arg: bigint, tx: number, confirmation_height: number): number {
32514 if(!isWasmInitialized) {
32515 throw new Error("initializeWasm() must be awaited first!");
32517 const nativeResponseValue = wasm.TS_ChannelMonitor_get_spendable_outputs(this_arg, tx, confirmation_height);
32518 return nativeResponseValue;
32520 // MUST_USE_RES bool ChannelMonitor_is_fully_resolved(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
32522 export function ChannelMonitor_is_fully_resolved(this_arg: bigint, logger: bigint): boolean {
32523 if(!isWasmInitialized) {
32524 throw new Error("initializeWasm() must be awaited first!");
32526 const nativeResponseValue = wasm.TS_ChannelMonitor_is_fully_resolved(this_arg, logger);
32527 return nativeResponseValue;
32529 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
32531 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
32532 if(!isWasmInitialized) {
32533 throw new Error("initializeWasm() must be awaited first!");
32535 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
32536 return nativeResponseValue;
32538 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
32540 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
32541 if(!isWasmInitialized) {
32542 throw new Error("initializeWasm() must be awaited first!");
32544 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser, arg_a, arg_b);
32545 return nativeResponseValue;
32547 // void OutPoint_free(struct LDKOutPoint this_obj);
32549 export function OutPoint_free(this_obj: bigint): void {
32550 if(!isWasmInitialized) {
32551 throw new Error("initializeWasm() must be awaited first!");
32553 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
32554 // debug statements here
32556 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
32558 export function OutPoint_get_txid(this_ptr: bigint): number {
32559 if(!isWasmInitialized) {
32560 throw new Error("initializeWasm() must be awaited first!");
32562 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
32563 return nativeResponseValue;
32565 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32567 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
32568 if(!isWasmInitialized) {
32569 throw new Error("initializeWasm() must be awaited first!");
32571 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
32572 // debug statements here
32574 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
32576 export function OutPoint_get_index(this_ptr: bigint): number {
32577 if(!isWasmInitialized) {
32578 throw new Error("initializeWasm() must be awaited first!");
32580 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
32581 return nativeResponseValue;
32583 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
32585 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
32586 if(!isWasmInitialized) {
32587 throw new Error("initializeWasm() must be awaited first!");
32589 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
32590 // debug statements here
32592 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
32594 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
32595 if(!isWasmInitialized) {
32596 throw new Error("initializeWasm() must be awaited first!");
32598 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
32599 return nativeResponseValue;
32601 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
32603 export function OutPoint_clone_ptr(arg: bigint): bigint {
32604 if(!isWasmInitialized) {
32605 throw new Error("initializeWasm() must be awaited first!");
32607 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
32608 return nativeResponseValue;
32610 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
32612 export function OutPoint_clone(orig: bigint): bigint {
32613 if(!isWasmInitialized) {
32614 throw new Error("initializeWasm() must be awaited first!");
32616 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
32617 return nativeResponseValue;
32619 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
32621 export function OutPoint_eq(a: bigint, b: bigint): boolean {
32622 if(!isWasmInitialized) {
32623 throw new Error("initializeWasm() must be awaited first!");
32625 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
32626 return nativeResponseValue;
32628 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
32630 export function OutPoint_hash(o: bigint): bigint {
32631 if(!isWasmInitialized) {
32632 throw new Error("initializeWasm() must be awaited first!");
32634 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
32635 return nativeResponseValue;
32637 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
32639 export function OutPoint_write(obj: bigint): number {
32640 if(!isWasmInitialized) {
32641 throw new Error("initializeWasm() must be awaited first!");
32643 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
32644 return nativeResponseValue;
32646 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
32648 export function OutPoint_read(ser: number): bigint {
32649 if(!isWasmInitialized) {
32650 throw new Error("initializeWasm() must be awaited first!");
32652 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
32653 return nativeResponseValue;
32655 // void InboundHTLCErr_free(struct LDKInboundHTLCErr this_obj);
32657 export function InboundHTLCErr_free(this_obj: bigint): void {
32658 if(!isWasmInitialized) {
32659 throw new Error("initializeWasm() must be awaited first!");
32661 const nativeResponseValue = wasm.TS_InboundHTLCErr_free(this_obj);
32662 // debug statements here
32664 // uint16_t InboundHTLCErr_get_err_code(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
32666 export function InboundHTLCErr_get_err_code(this_ptr: bigint): number {
32667 if(!isWasmInitialized) {
32668 throw new Error("initializeWasm() must be awaited first!");
32670 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_err_code(this_ptr);
32671 return nativeResponseValue;
32673 // void InboundHTLCErr_set_err_code(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, uint16_t val);
32675 export function InboundHTLCErr_set_err_code(this_ptr: bigint, val: number): void {
32676 if(!isWasmInitialized) {
32677 throw new Error("initializeWasm() must be awaited first!");
32679 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_err_code(this_ptr, val);
32680 // debug statements here
32682 // struct LDKCVec_u8Z InboundHTLCErr_get_err_data(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
32684 export function InboundHTLCErr_get_err_data(this_ptr: bigint): number {
32685 if(!isWasmInitialized) {
32686 throw new Error("initializeWasm() must be awaited first!");
32688 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_err_data(this_ptr);
32689 return nativeResponseValue;
32691 // void InboundHTLCErr_set_err_data(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32693 export function InboundHTLCErr_set_err_data(this_ptr: bigint, val: number): void {
32694 if(!isWasmInitialized) {
32695 throw new Error("initializeWasm() must be awaited first!");
32697 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_err_data(this_ptr, val);
32698 // debug statements here
32700 // struct LDKStr InboundHTLCErr_get_msg(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
32702 export function InboundHTLCErr_get_msg(this_ptr: bigint): number {
32703 if(!isWasmInitialized) {
32704 throw new Error("initializeWasm() must be awaited first!");
32706 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_msg(this_ptr);
32707 return nativeResponseValue;
32709 // void InboundHTLCErr_set_msg(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, struct LDKStr val);
32711 export function InboundHTLCErr_set_msg(this_ptr: bigint, val: number): void {
32712 if(!isWasmInitialized) {
32713 throw new Error("initializeWasm() must be awaited first!");
32715 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_msg(this_ptr, val);
32716 // debug statements here
32718 // MUST_USE_RES struct LDKInboundHTLCErr InboundHTLCErr_new(uint16_t err_code_arg, struct LDKCVec_u8Z err_data_arg, struct LDKStr msg_arg);
32720 export function InboundHTLCErr_new(err_code_arg: number, err_data_arg: number, msg_arg: number): bigint {
32721 if(!isWasmInitialized) {
32722 throw new Error("initializeWasm() must be awaited first!");
32724 const nativeResponseValue = wasm.TS_InboundHTLCErr_new(err_code_arg, err_data_arg, msg_arg);
32725 return nativeResponseValue;
32727 // uint64_t InboundHTLCErr_clone_ptr(LDKInboundHTLCErr *NONNULL_PTR arg);
32729 export function InboundHTLCErr_clone_ptr(arg: bigint): bigint {
32730 if(!isWasmInitialized) {
32731 throw new Error("initializeWasm() must be awaited first!");
32733 const nativeResponseValue = wasm.TS_InboundHTLCErr_clone_ptr(arg);
32734 return nativeResponseValue;
32736 // struct LDKInboundHTLCErr InboundHTLCErr_clone(const struct LDKInboundHTLCErr *NONNULL_PTR orig);
32738 export function InboundHTLCErr_clone(orig: bigint): bigint {
32739 if(!isWasmInitialized) {
32740 throw new Error("initializeWasm() must be awaited first!");
32742 const nativeResponseValue = wasm.TS_InboundHTLCErr_clone(orig);
32743 return nativeResponseValue;
32745 // uint64_t InboundHTLCErr_hash(const struct LDKInboundHTLCErr *NONNULL_PTR o);
32747 export function InboundHTLCErr_hash(o: bigint): bigint {
32748 if(!isWasmInitialized) {
32749 throw new Error("initializeWasm() must be awaited first!");
32751 const nativeResponseValue = wasm.TS_InboundHTLCErr_hash(o);
32752 return nativeResponseValue;
32754 // bool InboundHTLCErr_eq(const struct LDKInboundHTLCErr *NONNULL_PTR a, const struct LDKInboundHTLCErr *NONNULL_PTR b);
32756 export function InboundHTLCErr_eq(a: bigint, b: bigint): boolean {
32757 if(!isWasmInitialized) {
32758 throw new Error("initializeWasm() must be awaited first!");
32760 const nativeResponseValue = wasm.TS_InboundHTLCErr_eq(a, b);
32761 return nativeResponseValue;
32763 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ peel_payment_onion(const struct LDKUpdateAddHTLC *NONNULL_PTR msg, const struct LDKNodeSigner *NONNULL_PTR node_signer, const struct LDKLogger *NONNULL_PTR logger, uint32_t cur_height, bool accept_mpp_keysend, bool allow_skimmed_fees);
32765 export function peel_payment_onion(msg: bigint, node_signer: bigint, logger: bigint, cur_height: number, accept_mpp_keysend: boolean, allow_skimmed_fees: boolean): bigint {
32766 if(!isWasmInitialized) {
32767 throw new Error("initializeWasm() must be awaited first!");
32769 const nativeResponseValue = wasm.TS_peel_payment_onion(msg, node_signer, logger, cur_height, accept_mpp_keysend, allow_skimmed_fees);
32770 return nativeResponseValue;
32772 // void PendingHTLCRouting_free(struct LDKPendingHTLCRouting this_ptr);
32774 export function PendingHTLCRouting_free(this_ptr: bigint): void {
32775 if(!isWasmInitialized) {
32776 throw new Error("initializeWasm() must be awaited first!");
32778 const nativeResponseValue = wasm.TS_PendingHTLCRouting_free(this_ptr);
32779 // debug statements here
32781 // uint64_t PendingHTLCRouting_clone_ptr(LDKPendingHTLCRouting *NONNULL_PTR arg);
32783 export function PendingHTLCRouting_clone_ptr(arg: bigint): bigint {
32784 if(!isWasmInitialized) {
32785 throw new Error("initializeWasm() must be awaited first!");
32787 const nativeResponseValue = wasm.TS_PendingHTLCRouting_clone_ptr(arg);
32788 return nativeResponseValue;
32790 // struct LDKPendingHTLCRouting PendingHTLCRouting_clone(const struct LDKPendingHTLCRouting *NONNULL_PTR orig);
32792 export function PendingHTLCRouting_clone(orig: bigint): bigint {
32793 if(!isWasmInitialized) {
32794 throw new Error("initializeWasm() must be awaited first!");
32796 const nativeResponseValue = wasm.TS_PendingHTLCRouting_clone(orig);
32797 return nativeResponseValue;
32799 // struct LDKPendingHTLCRouting PendingHTLCRouting_forward(struct LDKOnionPacket onion_packet, uint64_t short_channel_id, struct LDKBlindedForward blinded);
32801 export function PendingHTLCRouting_forward(onion_packet: bigint, short_channel_id: bigint, blinded: bigint): bigint {
32802 if(!isWasmInitialized) {
32803 throw new Error("initializeWasm() must be awaited first!");
32805 const nativeResponseValue = wasm.TS_PendingHTLCRouting_forward(onion_packet, short_channel_id, blinded);
32806 return nativeResponseValue;
32808 // struct LDKPendingHTLCRouting PendingHTLCRouting_receive(struct LDKFinalOnionHopData payment_data, struct LDKCOption_CVec_u8ZZ payment_metadata, struct LDKCOption_PaymentContextZ payment_context, uint32_t incoming_cltv_expiry, struct LDKThirtyTwoBytes phantom_shared_secret, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs, bool requires_blinded_error);
32810 export function PendingHTLCRouting_receive(payment_data: bigint, payment_metadata: bigint, payment_context: bigint, incoming_cltv_expiry: number, phantom_shared_secret: number, custom_tlvs: number, requires_blinded_error: boolean): bigint {
32811 if(!isWasmInitialized) {
32812 throw new Error("initializeWasm() must be awaited first!");
32814 const nativeResponseValue = wasm.TS_PendingHTLCRouting_receive(payment_data, payment_metadata, payment_context, incoming_cltv_expiry, phantom_shared_secret, custom_tlvs, requires_blinded_error);
32815 return nativeResponseValue;
32817 // struct LDKPendingHTLCRouting PendingHTLCRouting_receive_keysend(struct LDKFinalOnionHopData payment_data, struct LDKThirtyTwoBytes payment_preimage, struct LDKCOption_CVec_u8ZZ payment_metadata, uint32_t incoming_cltv_expiry, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs, bool requires_blinded_error);
32819 export function PendingHTLCRouting_receive_keysend(payment_data: bigint, payment_preimage: number, payment_metadata: bigint, incoming_cltv_expiry: number, custom_tlvs: number, requires_blinded_error: boolean): bigint {
32820 if(!isWasmInitialized) {
32821 throw new Error("initializeWasm() must be awaited first!");
32823 const nativeResponseValue = wasm.TS_PendingHTLCRouting_receive_keysend(payment_data, payment_preimage, payment_metadata, incoming_cltv_expiry, custom_tlvs, requires_blinded_error);
32824 return nativeResponseValue;
32826 // void BlindedForward_free(struct LDKBlindedForward this_obj);
32828 export function BlindedForward_free(this_obj: bigint): void {
32829 if(!isWasmInitialized) {
32830 throw new Error("initializeWasm() must be awaited first!");
32832 const nativeResponseValue = wasm.TS_BlindedForward_free(this_obj);
32833 // debug statements here
32835 // struct LDKPublicKey BlindedForward_get_inbound_blinding_point(const struct LDKBlindedForward *NONNULL_PTR this_ptr);
32837 export function BlindedForward_get_inbound_blinding_point(this_ptr: bigint): number {
32838 if(!isWasmInitialized) {
32839 throw new Error("initializeWasm() must be awaited first!");
32841 const nativeResponseValue = wasm.TS_BlindedForward_get_inbound_blinding_point(this_ptr);
32842 return nativeResponseValue;
32844 // void BlindedForward_set_inbound_blinding_point(struct LDKBlindedForward *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32846 export function BlindedForward_set_inbound_blinding_point(this_ptr: bigint, val: number): void {
32847 if(!isWasmInitialized) {
32848 throw new Error("initializeWasm() must be awaited first!");
32850 const nativeResponseValue = wasm.TS_BlindedForward_set_inbound_blinding_point(this_ptr, val);
32851 // debug statements here
32853 // enum LDKBlindedFailure BlindedForward_get_failure(const struct LDKBlindedForward *NONNULL_PTR this_ptr);
32855 export function BlindedForward_get_failure(this_ptr: bigint): BlindedFailure {
32856 if(!isWasmInitialized) {
32857 throw new Error("initializeWasm() must be awaited first!");
32859 const nativeResponseValue = wasm.TS_BlindedForward_get_failure(this_ptr);
32860 return nativeResponseValue;
32862 // void BlindedForward_set_failure(struct LDKBlindedForward *NONNULL_PTR this_ptr, enum LDKBlindedFailure val);
32864 export function BlindedForward_set_failure(this_ptr: bigint, val: BlindedFailure): void {
32865 if(!isWasmInitialized) {
32866 throw new Error("initializeWasm() must be awaited first!");
32868 const nativeResponseValue = wasm.TS_BlindedForward_set_failure(this_ptr, val);
32869 // debug statements here
32871 // MUST_USE_RES struct LDKBlindedForward BlindedForward_new(struct LDKPublicKey inbound_blinding_point_arg, enum LDKBlindedFailure failure_arg);
32873 export function BlindedForward_new(inbound_blinding_point_arg: number, failure_arg: BlindedFailure): bigint {
32874 if(!isWasmInitialized) {
32875 throw new Error("initializeWasm() must be awaited first!");
32877 const nativeResponseValue = wasm.TS_BlindedForward_new(inbound_blinding_point_arg, failure_arg);
32878 return nativeResponseValue;
32880 // uint64_t BlindedForward_clone_ptr(LDKBlindedForward *NONNULL_PTR arg);
32882 export function BlindedForward_clone_ptr(arg: bigint): bigint {
32883 if(!isWasmInitialized) {
32884 throw new Error("initializeWasm() must be awaited first!");
32886 const nativeResponseValue = wasm.TS_BlindedForward_clone_ptr(arg);
32887 return nativeResponseValue;
32889 // struct LDKBlindedForward BlindedForward_clone(const struct LDKBlindedForward *NONNULL_PTR orig);
32891 export function BlindedForward_clone(orig: bigint): bigint {
32892 if(!isWasmInitialized) {
32893 throw new Error("initializeWasm() must be awaited first!");
32895 const nativeResponseValue = wasm.TS_BlindedForward_clone(orig);
32896 return nativeResponseValue;
32898 // uint64_t BlindedForward_hash(const struct LDKBlindedForward *NONNULL_PTR o);
32900 export function BlindedForward_hash(o: bigint): bigint {
32901 if(!isWasmInitialized) {
32902 throw new Error("initializeWasm() must be awaited first!");
32904 const nativeResponseValue = wasm.TS_BlindedForward_hash(o);
32905 return nativeResponseValue;
32907 // bool BlindedForward_eq(const struct LDKBlindedForward *NONNULL_PTR a, const struct LDKBlindedForward *NONNULL_PTR b);
32909 export function BlindedForward_eq(a: bigint, b: bigint): boolean {
32910 if(!isWasmInitialized) {
32911 throw new Error("initializeWasm() must be awaited first!");
32913 const nativeResponseValue = wasm.TS_BlindedForward_eq(a, b);
32914 return nativeResponseValue;
32916 // void PendingHTLCInfo_free(struct LDKPendingHTLCInfo this_obj);
32918 export function PendingHTLCInfo_free(this_obj: bigint): void {
32919 if(!isWasmInitialized) {
32920 throw new Error("initializeWasm() must be awaited first!");
32922 const nativeResponseValue = wasm.TS_PendingHTLCInfo_free(this_obj);
32923 // debug statements here
32925 // struct LDKPendingHTLCRouting PendingHTLCInfo_get_routing(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
32927 export function PendingHTLCInfo_get_routing(this_ptr: bigint): bigint {
32928 if(!isWasmInitialized) {
32929 throw new Error("initializeWasm() must be awaited first!");
32931 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_routing(this_ptr);
32932 return nativeResponseValue;
32934 // void PendingHTLCInfo_set_routing(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKPendingHTLCRouting val);
32936 export function PendingHTLCInfo_set_routing(this_ptr: bigint, val: bigint): void {
32937 if(!isWasmInitialized) {
32938 throw new Error("initializeWasm() must be awaited first!");
32940 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_routing(this_ptr, val);
32941 // debug statements here
32943 // const uint8_t (*PendingHTLCInfo_get_incoming_shared_secret(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr))[32];
32945 export function PendingHTLCInfo_get_incoming_shared_secret(this_ptr: bigint): number {
32946 if(!isWasmInitialized) {
32947 throw new Error("initializeWasm() must be awaited first!");
32949 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_incoming_shared_secret(this_ptr);
32950 return nativeResponseValue;
32952 // void PendingHTLCInfo_set_incoming_shared_secret(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32954 export function PendingHTLCInfo_set_incoming_shared_secret(this_ptr: bigint, val: number): void {
32955 if(!isWasmInitialized) {
32956 throw new Error("initializeWasm() must be awaited first!");
32958 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_incoming_shared_secret(this_ptr, val);
32959 // debug statements here
32961 // const uint8_t (*PendingHTLCInfo_get_payment_hash(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr))[32];
32963 export function PendingHTLCInfo_get_payment_hash(this_ptr: bigint): number {
32964 if(!isWasmInitialized) {
32965 throw new Error("initializeWasm() must be awaited first!");
32967 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_payment_hash(this_ptr);
32968 return nativeResponseValue;
32970 // void PendingHTLCInfo_set_payment_hash(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32972 export function PendingHTLCInfo_set_payment_hash(this_ptr: bigint, val: number): void {
32973 if(!isWasmInitialized) {
32974 throw new Error("initializeWasm() must be awaited first!");
32976 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_payment_hash(this_ptr, val);
32977 // debug statements here
32979 // struct LDKCOption_u64Z PendingHTLCInfo_get_incoming_amt_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
32981 export function PendingHTLCInfo_get_incoming_amt_msat(this_ptr: bigint): bigint {
32982 if(!isWasmInitialized) {
32983 throw new Error("initializeWasm() must be awaited first!");
32985 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_incoming_amt_msat(this_ptr);
32986 return nativeResponseValue;
32988 // void PendingHTLCInfo_set_incoming_amt_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32990 export function PendingHTLCInfo_set_incoming_amt_msat(this_ptr: bigint, val: bigint): void {
32991 if(!isWasmInitialized) {
32992 throw new Error("initializeWasm() must be awaited first!");
32994 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_incoming_amt_msat(this_ptr, val);
32995 // debug statements here
32997 // uint64_t PendingHTLCInfo_get_outgoing_amt_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
32999 export function PendingHTLCInfo_get_outgoing_amt_msat(this_ptr: bigint): bigint {
33000 if(!isWasmInitialized) {
33001 throw new Error("initializeWasm() must be awaited first!");
33003 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_outgoing_amt_msat(this_ptr);
33004 return nativeResponseValue;
33006 // void PendingHTLCInfo_set_outgoing_amt_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, uint64_t val);
33008 export function PendingHTLCInfo_set_outgoing_amt_msat(this_ptr: bigint, val: bigint): void {
33009 if(!isWasmInitialized) {
33010 throw new Error("initializeWasm() must be awaited first!");
33012 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_outgoing_amt_msat(this_ptr, val);
33013 // debug statements here
33015 // uint32_t PendingHTLCInfo_get_outgoing_cltv_value(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
33017 export function PendingHTLCInfo_get_outgoing_cltv_value(this_ptr: bigint): number {
33018 if(!isWasmInitialized) {
33019 throw new Error("initializeWasm() must be awaited first!");
33021 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_outgoing_cltv_value(this_ptr);
33022 return nativeResponseValue;
33024 // void PendingHTLCInfo_set_outgoing_cltv_value(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, uint32_t val);
33026 export function PendingHTLCInfo_set_outgoing_cltv_value(this_ptr: bigint, val: number): void {
33027 if(!isWasmInitialized) {
33028 throw new Error("initializeWasm() must be awaited first!");
33030 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_outgoing_cltv_value(this_ptr, val);
33031 // debug statements here
33033 // struct LDKCOption_u64Z PendingHTLCInfo_get_skimmed_fee_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
33035 export function PendingHTLCInfo_get_skimmed_fee_msat(this_ptr: bigint): bigint {
33036 if(!isWasmInitialized) {
33037 throw new Error("initializeWasm() must be awaited first!");
33039 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_skimmed_fee_msat(this_ptr);
33040 return nativeResponseValue;
33042 // void PendingHTLCInfo_set_skimmed_fee_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33044 export function PendingHTLCInfo_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
33045 if(!isWasmInitialized) {
33046 throw new Error("initializeWasm() must be awaited first!");
33048 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_skimmed_fee_msat(this_ptr, val);
33049 // debug statements here
33051 // MUST_USE_RES struct LDKPendingHTLCInfo PendingHTLCInfo_new(struct LDKPendingHTLCRouting routing_arg, struct LDKThirtyTwoBytes incoming_shared_secret_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_u64Z incoming_amt_msat_arg, uint64_t outgoing_amt_msat_arg, uint32_t outgoing_cltv_value_arg, struct LDKCOption_u64Z skimmed_fee_msat_arg);
33053 export function PendingHTLCInfo_new(routing_arg: bigint, incoming_shared_secret_arg: number, payment_hash_arg: number, incoming_amt_msat_arg: bigint, outgoing_amt_msat_arg: bigint, outgoing_cltv_value_arg: number, skimmed_fee_msat_arg: bigint): bigint {
33054 if(!isWasmInitialized) {
33055 throw new Error("initializeWasm() must be awaited first!");
33057 const nativeResponseValue = wasm.TS_PendingHTLCInfo_new(routing_arg, incoming_shared_secret_arg, payment_hash_arg, incoming_amt_msat_arg, outgoing_amt_msat_arg, outgoing_cltv_value_arg, skimmed_fee_msat_arg);
33058 return nativeResponseValue;
33060 // uint64_t PendingHTLCInfo_clone_ptr(LDKPendingHTLCInfo *NONNULL_PTR arg);
33062 export function PendingHTLCInfo_clone_ptr(arg: bigint): bigint {
33063 if(!isWasmInitialized) {
33064 throw new Error("initializeWasm() must be awaited first!");
33066 const nativeResponseValue = wasm.TS_PendingHTLCInfo_clone_ptr(arg);
33067 return nativeResponseValue;
33069 // struct LDKPendingHTLCInfo PendingHTLCInfo_clone(const struct LDKPendingHTLCInfo *NONNULL_PTR orig);
33071 export function PendingHTLCInfo_clone(orig: bigint): bigint {
33072 if(!isWasmInitialized) {
33073 throw new Error("initializeWasm() must be awaited first!");
33075 const nativeResponseValue = wasm.TS_PendingHTLCInfo_clone(orig);
33076 return nativeResponseValue;
33078 // enum LDKBlindedFailure BlindedFailure_clone(const enum LDKBlindedFailure *NONNULL_PTR orig);
33080 export function BlindedFailure_clone(orig: bigint): BlindedFailure {
33081 if(!isWasmInitialized) {
33082 throw new Error("initializeWasm() must be awaited first!");
33084 const nativeResponseValue = wasm.TS_BlindedFailure_clone(orig);
33085 return nativeResponseValue;
33087 // enum LDKBlindedFailure BlindedFailure_from_introduction_node(void);
33089 export function BlindedFailure_from_introduction_node(): BlindedFailure {
33090 if(!isWasmInitialized) {
33091 throw new Error("initializeWasm() must be awaited first!");
33093 const nativeResponseValue = wasm.TS_BlindedFailure_from_introduction_node();
33094 return nativeResponseValue;
33096 // enum LDKBlindedFailure BlindedFailure_from_blinded_node(void);
33098 export function BlindedFailure_from_blinded_node(): BlindedFailure {
33099 if(!isWasmInitialized) {
33100 throw new Error("initializeWasm() must be awaited first!");
33102 const nativeResponseValue = wasm.TS_BlindedFailure_from_blinded_node();
33103 return nativeResponseValue;
33105 // uint64_t BlindedFailure_hash(const enum LDKBlindedFailure *NONNULL_PTR o);
33107 export function BlindedFailure_hash(o: bigint): bigint {
33108 if(!isWasmInitialized) {
33109 throw new Error("initializeWasm() must be awaited first!");
33111 const nativeResponseValue = wasm.TS_BlindedFailure_hash(o);
33112 return nativeResponseValue;
33114 // bool BlindedFailure_eq(const enum LDKBlindedFailure *NONNULL_PTR a, const enum LDKBlindedFailure *NONNULL_PTR b);
33116 export function BlindedFailure_eq(a: bigint, b: bigint): boolean {
33117 if(!isWasmInitialized) {
33118 throw new Error("initializeWasm() must be awaited first!");
33120 const nativeResponseValue = wasm.TS_BlindedFailure_eq(a, b);
33121 return nativeResponseValue;
33123 // void FailureCode_free(struct LDKFailureCode this_ptr);
33125 export function FailureCode_free(this_ptr: bigint): void {
33126 if(!isWasmInitialized) {
33127 throw new Error("initializeWasm() must be awaited first!");
33129 const nativeResponseValue = wasm.TS_FailureCode_free(this_ptr);
33130 // debug statements here
33132 // uint64_t FailureCode_clone_ptr(LDKFailureCode *NONNULL_PTR arg);
33134 export function FailureCode_clone_ptr(arg: bigint): bigint {
33135 if(!isWasmInitialized) {
33136 throw new Error("initializeWasm() must be awaited first!");
33138 const nativeResponseValue = wasm.TS_FailureCode_clone_ptr(arg);
33139 return nativeResponseValue;
33141 // struct LDKFailureCode FailureCode_clone(const struct LDKFailureCode *NONNULL_PTR orig);
33143 export function FailureCode_clone(orig: bigint): bigint {
33144 if(!isWasmInitialized) {
33145 throw new Error("initializeWasm() must be awaited first!");
33147 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
33148 return nativeResponseValue;
33150 // struct LDKFailureCode FailureCode_temporary_node_failure(void);
33152 export function FailureCode_temporary_node_failure(): bigint {
33153 if(!isWasmInitialized) {
33154 throw new Error("initializeWasm() must be awaited first!");
33156 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
33157 return nativeResponseValue;
33159 // struct LDKFailureCode FailureCode_required_node_feature_missing(void);
33161 export function FailureCode_required_node_feature_missing(): bigint {
33162 if(!isWasmInitialized) {
33163 throw new Error("initializeWasm() must be awaited first!");
33165 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
33166 return nativeResponseValue;
33168 // struct LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
33170 export function FailureCode_incorrect_or_unknown_payment_details(): bigint {
33171 if(!isWasmInitialized) {
33172 throw new Error("initializeWasm() must be awaited first!");
33174 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
33175 return nativeResponseValue;
33177 // struct LDKFailureCode FailureCode_invalid_onion_payload(struct LDKCOption_C2Tuple_u64u16ZZ a);
33179 export function FailureCode_invalid_onion_payload(a: bigint): bigint {
33180 if(!isWasmInitialized) {
33181 throw new Error("initializeWasm() must be awaited first!");
33183 const nativeResponseValue = wasm.TS_FailureCode_invalid_onion_payload(a);
33184 return nativeResponseValue;
33186 // void ChannelManager_free(struct LDKChannelManager this_obj);
33188 export function ChannelManager_free(this_obj: bigint): void {
33189 if(!isWasmInitialized) {
33190 throw new Error("initializeWasm() must be awaited first!");
33192 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
33193 // debug statements here
33195 // void ChainParameters_free(struct LDKChainParameters this_obj);
33197 export function ChainParameters_free(this_obj: bigint): void {
33198 if(!isWasmInitialized) {
33199 throw new Error("initializeWasm() must be awaited first!");
33201 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
33202 // debug statements here
33204 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
33206 export function ChainParameters_get_network(this_ptr: bigint): Network {
33207 if(!isWasmInitialized) {
33208 throw new Error("initializeWasm() must be awaited first!");
33210 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
33211 return nativeResponseValue;
33213 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
33215 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
33216 if(!isWasmInitialized) {
33217 throw new Error("initializeWasm() must be awaited first!");
33219 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
33220 // debug statements here
33222 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
33224 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
33225 if(!isWasmInitialized) {
33226 throw new Error("initializeWasm() must be awaited first!");
33228 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
33229 return nativeResponseValue;
33231 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
33233 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
33234 if(!isWasmInitialized) {
33235 throw new Error("initializeWasm() must be awaited first!");
33237 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
33238 // debug statements here
33240 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
33242 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
33243 if(!isWasmInitialized) {
33244 throw new Error("initializeWasm() must be awaited first!");
33246 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
33247 return nativeResponseValue;
33249 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
33251 export function ChainParameters_clone_ptr(arg: bigint): bigint {
33252 if(!isWasmInitialized) {
33253 throw new Error("initializeWasm() must be awaited first!");
33255 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
33256 return nativeResponseValue;
33258 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
33260 export function ChainParameters_clone(orig: bigint): bigint {
33261 if(!isWasmInitialized) {
33262 throw new Error("initializeWasm() must be awaited first!");
33264 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
33265 return nativeResponseValue;
33267 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
33269 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
33270 if(!isWasmInitialized) {
33271 throw new Error("initializeWasm() must be awaited first!");
33273 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
33274 // debug statements here
33276 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
33278 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
33279 if(!isWasmInitialized) {
33280 throw new Error("initializeWasm() must be awaited first!");
33282 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
33283 return nativeResponseValue;
33285 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
33287 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
33288 if(!isWasmInitialized) {
33289 throw new Error("initializeWasm() must be awaited first!");
33291 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
33292 // debug statements here
33294 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
33296 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
33297 if(!isWasmInitialized) {
33298 throw new Error("initializeWasm() must be awaited first!");
33300 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
33301 return nativeResponseValue;
33303 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
33305 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
33306 if(!isWasmInitialized) {
33307 throw new Error("initializeWasm() must be awaited first!");
33309 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
33310 // debug statements here
33312 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
33314 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
33315 if(!isWasmInitialized) {
33316 throw new Error("initializeWasm() must be awaited first!");
33318 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
33319 return nativeResponseValue;
33321 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
33323 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
33324 if(!isWasmInitialized) {
33325 throw new Error("initializeWasm() must be awaited first!");
33327 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
33328 // debug statements here
33330 // 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);
33332 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
33333 if(!isWasmInitialized) {
33334 throw new Error("initializeWasm() must be awaited first!");
33336 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
33337 return nativeResponseValue;
33339 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
33341 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
33342 if(!isWasmInitialized) {
33343 throw new Error("initializeWasm() must be awaited first!");
33345 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
33346 return nativeResponseValue;
33348 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
33350 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
33351 if(!isWasmInitialized) {
33352 throw new Error("initializeWasm() must be awaited first!");
33354 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
33355 return nativeResponseValue;
33357 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
33359 export function ChannelCounterparty_free(this_obj: bigint): void {
33360 if(!isWasmInitialized) {
33361 throw new Error("initializeWasm() must be awaited first!");
33363 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
33364 // debug statements here
33366 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33368 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
33369 if(!isWasmInitialized) {
33370 throw new Error("initializeWasm() must be awaited first!");
33372 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
33373 return nativeResponseValue;
33375 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33377 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
33378 if(!isWasmInitialized) {
33379 throw new Error("initializeWasm() must be awaited first!");
33381 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
33382 // debug statements here
33384 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33386 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
33387 if(!isWasmInitialized) {
33388 throw new Error("initializeWasm() must be awaited first!");
33390 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
33391 return nativeResponseValue;
33393 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
33395 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
33396 if(!isWasmInitialized) {
33397 throw new Error("initializeWasm() must be awaited first!");
33399 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
33400 // debug statements here
33402 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33404 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
33405 if(!isWasmInitialized) {
33406 throw new Error("initializeWasm() must be awaited first!");
33408 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
33409 return nativeResponseValue;
33411 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
33413 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
33414 if(!isWasmInitialized) {
33415 throw new Error("initializeWasm() must be awaited first!");
33417 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
33418 // debug statements here
33420 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33422 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
33423 if(!isWasmInitialized) {
33424 throw new Error("initializeWasm() must be awaited first!");
33426 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
33427 return nativeResponseValue;
33429 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
33431 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
33432 if(!isWasmInitialized) {
33433 throw new Error("initializeWasm() must be awaited first!");
33435 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
33436 // debug statements here
33438 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33440 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
33441 if(!isWasmInitialized) {
33442 throw new Error("initializeWasm() must be awaited first!");
33444 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
33445 return nativeResponseValue;
33447 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33449 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33450 if(!isWasmInitialized) {
33451 throw new Error("initializeWasm() must be awaited first!");
33453 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
33454 // debug statements here
33456 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
33458 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
33459 if(!isWasmInitialized) {
33460 throw new Error("initializeWasm() must be awaited first!");
33462 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
33463 return nativeResponseValue;
33465 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33467 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
33468 if(!isWasmInitialized) {
33469 throw new Error("initializeWasm() must be awaited first!");
33471 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
33472 // debug statements here
33474 // 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);
33476 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 {
33477 if(!isWasmInitialized) {
33478 throw new Error("initializeWasm() must be awaited first!");
33480 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);
33481 return nativeResponseValue;
33483 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
33485 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
33486 if(!isWasmInitialized) {
33487 throw new Error("initializeWasm() must be awaited first!");
33489 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
33490 return nativeResponseValue;
33492 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
33494 export function ChannelCounterparty_clone(orig: bigint): bigint {
33495 if(!isWasmInitialized) {
33496 throw new Error("initializeWasm() must be awaited first!");
33498 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
33499 return nativeResponseValue;
33501 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
33503 export function ChannelDetails_free(this_obj: bigint): void {
33504 if(!isWasmInitialized) {
33505 throw new Error("initializeWasm() must be awaited first!");
33507 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
33508 // debug statements here
33510 // struct LDKChannelId ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33512 export function ChannelDetails_get_channel_id(this_ptr: bigint): bigint {
33513 if(!isWasmInitialized) {
33514 throw new Error("initializeWasm() must be awaited first!");
33516 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
33517 return nativeResponseValue;
33519 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelId val);
33521 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: bigint): void {
33522 if(!isWasmInitialized) {
33523 throw new Error("initializeWasm() must be awaited first!");
33525 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
33526 // debug statements here
33528 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33530 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
33531 if(!isWasmInitialized) {
33532 throw new Error("initializeWasm() must be awaited first!");
33534 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
33535 return nativeResponseValue;
33537 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
33539 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
33540 if(!isWasmInitialized) {
33541 throw new Error("initializeWasm() must be awaited first!");
33543 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
33544 // debug statements here
33546 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33548 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
33549 if(!isWasmInitialized) {
33550 throw new Error("initializeWasm() must be awaited first!");
33552 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
33553 return nativeResponseValue;
33555 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
33557 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
33558 if(!isWasmInitialized) {
33559 throw new Error("initializeWasm() must be awaited first!");
33561 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
33562 // debug statements here
33564 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33566 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
33567 if(!isWasmInitialized) {
33568 throw new Error("initializeWasm() must be awaited first!");
33570 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
33571 return nativeResponseValue;
33573 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
33575 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
33576 if(!isWasmInitialized) {
33577 throw new Error("initializeWasm() must be awaited first!");
33579 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
33580 // debug statements here
33582 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33584 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
33585 if(!isWasmInitialized) {
33586 throw new Error("initializeWasm() must be awaited first!");
33588 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
33589 return nativeResponseValue;
33591 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33593 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
33594 if(!isWasmInitialized) {
33595 throw new Error("initializeWasm() must be awaited first!");
33597 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
33598 // debug statements here
33600 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33602 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
33603 if(!isWasmInitialized) {
33604 throw new Error("initializeWasm() must be awaited first!");
33606 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
33607 return nativeResponseValue;
33609 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33611 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
33612 if(!isWasmInitialized) {
33613 throw new Error("initializeWasm() must be awaited first!");
33615 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
33616 // debug statements here
33618 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33620 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
33621 if(!isWasmInitialized) {
33622 throw new Error("initializeWasm() must be awaited first!");
33624 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
33625 return nativeResponseValue;
33627 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33629 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
33630 if(!isWasmInitialized) {
33631 throw new Error("initializeWasm() must be awaited first!");
33633 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
33634 // debug statements here
33636 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33638 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
33639 if(!isWasmInitialized) {
33640 throw new Error("initializeWasm() must be awaited first!");
33642 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
33643 return nativeResponseValue;
33645 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33647 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
33648 if(!isWasmInitialized) {
33649 throw new Error("initializeWasm() must be awaited first!");
33651 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
33652 // debug statements here
33654 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33656 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
33657 if(!isWasmInitialized) {
33658 throw new Error("initializeWasm() must be awaited first!");
33660 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
33661 return nativeResponseValue;
33663 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33665 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
33666 if(!isWasmInitialized) {
33667 throw new Error("initializeWasm() must be awaited first!");
33669 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
33670 // debug statements here
33672 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33674 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
33675 if(!isWasmInitialized) {
33676 throw new Error("initializeWasm() must be awaited first!");
33678 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
33679 return nativeResponseValue;
33681 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
33683 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
33684 if(!isWasmInitialized) {
33685 throw new Error("initializeWasm() must be awaited first!");
33687 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
33688 // debug statements here
33690 // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33692 export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
33693 if(!isWasmInitialized) {
33694 throw new Error("initializeWasm() must be awaited first!");
33696 const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
33697 return nativeResponseValue;
33699 // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
33701 export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
33702 if(!isWasmInitialized) {
33703 throw new Error("initializeWasm() must be awaited first!");
33705 const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
33706 // debug statements here
33708 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33710 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
33711 if(!isWasmInitialized) {
33712 throw new Error("initializeWasm() must be awaited first!");
33714 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
33715 return nativeResponseValue;
33717 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33719 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
33720 if(!isWasmInitialized) {
33721 throw new Error("initializeWasm() must be awaited first!");
33723 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
33724 // debug statements here
33726 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33728 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
33729 if(!isWasmInitialized) {
33730 throw new Error("initializeWasm() must be awaited first!");
33732 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
33733 return nativeResponseValue;
33735 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33737 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
33738 if(!isWasmInitialized) {
33739 throw new Error("initializeWasm() must be awaited first!");
33741 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
33742 // debug statements here
33744 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33746 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
33747 if(!isWasmInitialized) {
33748 throw new Error("initializeWasm() must be awaited first!");
33750 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
33751 return nativeResponseValue;
33753 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33755 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
33756 if(!isWasmInitialized) {
33757 throw new Error("initializeWasm() must be awaited first!");
33759 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
33760 // debug statements here
33762 // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33764 export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
33765 if(!isWasmInitialized) {
33766 throw new Error("initializeWasm() must be awaited first!");
33768 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
33769 return nativeResponseValue;
33771 // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33773 export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33774 if(!isWasmInitialized) {
33775 throw new Error("initializeWasm() must be awaited first!");
33777 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
33778 // debug statements here
33780 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33782 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
33783 if(!isWasmInitialized) {
33784 throw new Error("initializeWasm() must be awaited first!");
33786 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
33787 return nativeResponseValue;
33789 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
33791 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
33792 if(!isWasmInitialized) {
33793 throw new Error("initializeWasm() must be awaited first!");
33795 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
33796 // debug statements here
33798 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33800 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
33801 if(!isWasmInitialized) {
33802 throw new Error("initializeWasm() must be awaited first!");
33804 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
33805 return nativeResponseValue;
33807 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
33809 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
33810 if(!isWasmInitialized) {
33811 throw new Error("initializeWasm() must be awaited first!");
33813 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
33814 // debug statements here
33816 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33818 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
33819 if(!isWasmInitialized) {
33820 throw new Error("initializeWasm() must be awaited first!");
33822 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
33823 return nativeResponseValue;
33825 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
33827 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
33828 if(!isWasmInitialized) {
33829 throw new Error("initializeWasm() must be awaited first!");
33831 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
33832 // debug statements here
33834 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33836 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
33837 if(!isWasmInitialized) {
33838 throw new Error("initializeWasm() must be awaited first!");
33840 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
33841 return nativeResponseValue;
33843 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
33845 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
33846 if(!isWasmInitialized) {
33847 throw new Error("initializeWasm() must be awaited first!");
33849 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
33850 // debug statements here
33852 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33854 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
33855 if(!isWasmInitialized) {
33856 throw new Error("initializeWasm() must be awaited first!");
33858 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
33859 return nativeResponseValue;
33861 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
33863 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
33864 if(!isWasmInitialized) {
33865 throw new Error("initializeWasm() must be awaited first!");
33867 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
33868 // debug statements here
33870 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33872 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
33873 if(!isWasmInitialized) {
33874 throw new Error("initializeWasm() must be awaited first!");
33876 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
33877 return nativeResponseValue;
33879 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
33881 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
33882 if(!isWasmInitialized) {
33883 throw new Error("initializeWasm() must be awaited first!");
33885 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
33886 // debug statements here
33888 // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33890 export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
33891 if(!isWasmInitialized) {
33892 throw new Error("initializeWasm() must be awaited first!");
33894 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
33895 return nativeResponseValue;
33897 // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
33899 export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
33900 if(!isWasmInitialized) {
33901 throw new Error("initializeWasm() must be awaited first!");
33903 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
33904 // debug statements here
33906 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33908 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
33909 if(!isWasmInitialized) {
33910 throw new Error("initializeWasm() must be awaited first!");
33912 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
33913 return nativeResponseValue;
33915 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
33917 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
33918 if(!isWasmInitialized) {
33919 throw new Error("initializeWasm() must be awaited first!");
33921 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
33922 // debug statements here
33924 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33926 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
33927 if(!isWasmInitialized) {
33928 throw new Error("initializeWasm() must be awaited first!");
33930 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
33931 return nativeResponseValue;
33933 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
33935 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
33936 if(!isWasmInitialized) {
33937 throw new Error("initializeWasm() must be awaited first!");
33939 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
33940 // debug statements here
33942 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33944 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
33945 if(!isWasmInitialized) {
33946 throw new Error("initializeWasm() must be awaited first!");
33948 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
33949 return nativeResponseValue;
33951 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33953 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33954 if(!isWasmInitialized) {
33955 throw new Error("initializeWasm() must be awaited first!");
33957 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
33958 // debug statements here
33960 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33962 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
33963 if(!isWasmInitialized) {
33964 throw new Error("initializeWasm() must be awaited first!");
33966 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
33967 return nativeResponseValue;
33969 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33971 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
33972 if(!isWasmInitialized) {
33973 throw new Error("initializeWasm() must be awaited first!");
33975 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
33976 // debug statements here
33978 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
33980 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
33981 if(!isWasmInitialized) {
33982 throw new Error("initializeWasm() must be awaited first!");
33984 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
33985 return nativeResponseValue;
33987 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
33989 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
33990 if(!isWasmInitialized) {
33991 throw new Error("initializeWasm() must be awaited first!");
33993 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
33994 // debug statements here
33996 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
33998 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
33999 if(!isWasmInitialized) {
34000 throw new Error("initializeWasm() must be awaited first!");
34002 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
34003 return nativeResponseValue;
34005 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
34007 export function ChannelDetails_clone(orig: bigint): bigint {
34008 if(!isWasmInitialized) {
34009 throw new Error("initializeWasm() must be awaited first!");
34011 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
34012 return nativeResponseValue;
34014 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
34016 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
34017 if(!isWasmInitialized) {
34018 throw new Error("initializeWasm() must be awaited first!");
34020 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
34021 return nativeResponseValue;
34023 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
34025 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
34026 if(!isWasmInitialized) {
34027 throw new Error("initializeWasm() must be awaited first!");
34029 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
34030 return nativeResponseValue;
34032 // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
34034 export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
34035 if(!isWasmInitialized) {
34036 throw new Error("initializeWasm() must be awaited first!");
34038 const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
34039 return nativeResponseValue;
34041 // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
34043 export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
34044 if(!isWasmInitialized) {
34045 throw new Error("initializeWasm() must be awaited first!");
34047 const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
34048 return nativeResponseValue;
34050 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
34052 export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
34053 if(!isWasmInitialized) {
34054 throw new Error("initializeWasm() must be awaited first!");
34056 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
34057 return nativeResponseValue;
34059 // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
34061 export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
34062 if(!isWasmInitialized) {
34063 throw new Error("initializeWasm() must be awaited first!");
34065 const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
34066 return nativeResponseValue;
34068 // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
34070 export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
34071 if(!isWasmInitialized) {
34072 throw new Error("initializeWasm() must be awaited first!");
34074 const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
34075 return nativeResponseValue;
34077 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
34079 export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
34080 if(!isWasmInitialized) {
34081 throw new Error("initializeWasm() must be awaited first!");
34083 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
34084 return nativeResponseValue;
34086 // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
34088 export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
34089 if(!isWasmInitialized) {
34090 throw new Error("initializeWasm() must be awaited first!");
34092 const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
34093 return nativeResponseValue;
34095 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
34097 export function RecentPaymentDetails_free(this_ptr: bigint): void {
34098 if(!isWasmInitialized) {
34099 throw new Error("initializeWasm() must be awaited first!");
34101 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
34102 // debug statements here
34104 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
34106 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
34107 if(!isWasmInitialized) {
34108 throw new Error("initializeWasm() must be awaited first!");
34110 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
34111 return nativeResponseValue;
34113 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
34115 export function RecentPaymentDetails_clone(orig: bigint): bigint {
34116 if(!isWasmInitialized) {
34117 throw new Error("initializeWasm() must be awaited first!");
34119 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
34120 return nativeResponseValue;
34122 // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
34124 export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
34125 if(!isWasmInitialized) {
34126 throw new Error("initializeWasm() must be awaited first!");
34128 const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
34129 return nativeResponseValue;
34131 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
34133 export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
34134 if(!isWasmInitialized) {
34135 throw new Error("initializeWasm() must be awaited first!");
34137 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
34138 return nativeResponseValue;
34140 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
34142 export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
34143 if(!isWasmInitialized) {
34144 throw new Error("initializeWasm() must be awaited first!");
34146 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
34147 return nativeResponseValue;
34149 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
34151 export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
34152 if(!isWasmInitialized) {
34153 throw new Error("initializeWasm() must be awaited first!");
34155 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
34156 return nativeResponseValue;
34158 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
34160 export function PhantomRouteHints_free(this_obj: bigint): void {
34161 if(!isWasmInitialized) {
34162 throw new Error("initializeWasm() must be awaited first!");
34164 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
34165 // debug statements here
34167 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
34169 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
34170 if(!isWasmInitialized) {
34171 throw new Error("initializeWasm() must be awaited first!");
34173 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
34174 return nativeResponseValue;
34176 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
34178 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
34179 if(!isWasmInitialized) {
34180 throw new Error("initializeWasm() must be awaited first!");
34182 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
34183 // debug statements here
34185 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
34187 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
34188 if(!isWasmInitialized) {
34189 throw new Error("initializeWasm() must be awaited first!");
34191 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
34192 return nativeResponseValue;
34194 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
34196 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
34197 if(!isWasmInitialized) {
34198 throw new Error("initializeWasm() must be awaited first!");
34200 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
34201 // debug statements here
34203 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
34205 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
34206 if(!isWasmInitialized) {
34207 throw new Error("initializeWasm() must be awaited first!");
34209 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
34210 return nativeResponseValue;
34212 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34214 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
34215 if(!isWasmInitialized) {
34216 throw new Error("initializeWasm() must be awaited first!");
34218 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
34219 // debug statements here
34221 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
34223 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
34224 if(!isWasmInitialized) {
34225 throw new Error("initializeWasm() must be awaited first!");
34227 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
34228 return nativeResponseValue;
34230 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
34232 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
34233 if(!isWasmInitialized) {
34234 throw new Error("initializeWasm() must be awaited first!");
34236 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
34237 return nativeResponseValue;
34239 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
34241 export function PhantomRouteHints_clone(orig: bigint): bigint {
34242 if(!isWasmInitialized) {
34243 throw new Error("initializeWasm() must be awaited first!");
34245 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
34246 return nativeResponseValue;
34248 // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKUserConfig config, struct LDKChainParameters params, uint32_t current_timestamp);
34250 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, entropy_source: bigint, node_signer: bigint, signer_provider: bigint, config: bigint, params: bigint, current_timestamp: number): bigint {
34251 if(!isWasmInitialized) {
34252 throw new Error("initializeWasm() must be awaited first!");
34254 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
34255 return nativeResponseValue;
34257 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
34259 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
34260 if(!isWasmInitialized) {
34261 throw new Error("initializeWasm() must be awaited first!");
34263 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
34264 return nativeResponseValue;
34266 // MUST_USE_RES struct LDKCResult_ChannelIdAPIErrorZ 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 LDKChannelId temporary_channel_id, struct LDKUserConfig override_config);
34268 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, temporary_channel_id: bigint, override_config: bigint): bigint {
34269 if(!isWasmInitialized) {
34270 throw new Error("initializeWasm() must be awaited first!");
34272 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, temporary_channel_id, override_config);
34273 return nativeResponseValue;
34275 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
34277 export function ChannelManager_list_channels(this_arg: bigint): number {
34278 if(!isWasmInitialized) {
34279 throw new Error("initializeWasm() must be awaited first!");
34281 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
34282 return nativeResponseValue;
34284 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
34286 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
34287 if(!isWasmInitialized) {
34288 throw new Error("initializeWasm() must be awaited first!");
34290 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
34291 return nativeResponseValue;
34293 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
34295 export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
34296 if(!isWasmInitialized) {
34297 throw new Error("initializeWasm() must be awaited first!");
34299 const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
34300 return nativeResponseValue;
34302 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
34304 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
34305 if(!isWasmInitialized) {
34306 throw new Error("initializeWasm() must be awaited first!");
34308 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
34309 return nativeResponseValue;
34311 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
34313 export function ChannelManager_close_channel(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
34314 if(!isWasmInitialized) {
34315 throw new Error("initializeWasm() must be awaited first!");
34317 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
34318 return nativeResponseValue;
34320 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_feerate_and_script(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u32Z target_feerate_sats_per_1000_weight, struct LDKShutdownScript shutdown_script);
34322 export function ChannelManager_close_channel_with_feerate_and_script(this_arg: bigint, channel_id: bigint, counterparty_node_id: number, target_feerate_sats_per_1000_weight: bigint, shutdown_script: bigint): bigint {
34323 if(!isWasmInitialized) {
34324 throw new Error("initializeWasm() must be awaited first!");
34326 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_feerate_and_script(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight, shutdown_script);
34327 return nativeResponseValue;
34329 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
34331 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
34332 if(!isWasmInitialized) {
34333 throw new Error("initializeWasm() must be awaited first!");
34335 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
34336 return nativeResponseValue;
34338 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
34340 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
34341 if(!isWasmInitialized) {
34342 throw new Error("initializeWasm() must be awaited first!");
34344 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
34345 return nativeResponseValue;
34347 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
34349 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
34350 if(!isWasmInitialized) {
34351 throw new Error("initializeWasm() must be awaited first!");
34353 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
34354 // debug statements here
34356 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
34358 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
34359 if(!isWasmInitialized) {
34360 throw new Error("initializeWasm() must be awaited first!");
34362 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
34363 // debug statements here
34365 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment_with_route(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
34367 export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
34368 if(!isWasmInitialized) {
34369 throw new Error("initializeWasm() must be awaited first!");
34371 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
34372 return nativeResponseValue;
34374 // MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
34376 export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
34377 if(!isWasmInitialized) {
34378 throw new Error("initializeWasm() must be awaited first!");
34380 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
34381 return nativeResponseValue;
34383 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
34385 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
34386 if(!isWasmInitialized) {
34387 throw new Error("initializeWasm() must be awaited first!");
34389 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
34390 // debug statements here
34392 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
34394 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
34395 if(!isWasmInitialized) {
34396 throw new Error("initializeWasm() must be awaited first!");
34398 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
34399 return nativeResponseValue;
34401 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
34403 export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
34404 if(!isWasmInitialized) {
34405 throw new Error("initializeWasm() must be awaited first!");
34407 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
34408 return nativeResponseValue;
34410 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
34412 export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
34413 if(!isWasmInitialized) {
34414 throw new Error("initializeWasm() must be awaited first!");
34416 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
34417 return nativeResponseValue;
34419 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_spontaneous_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, uint64_t amount_msat, uint32_t final_cltv_expiry_delta, struct LDKCOption_u64Z liquidity_limit_multiplier);
34421 export function ChannelManager_send_spontaneous_preflight_probes(this_arg: bigint, node_id: number, amount_msat: bigint, final_cltv_expiry_delta: number, liquidity_limit_multiplier: bigint): bigint {
34422 if(!isWasmInitialized) {
34423 throw new Error("initializeWasm() must be awaited first!");
34425 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
34426 return nativeResponseValue;
34428 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKRouteParameters route_params, struct LDKCOption_u64Z liquidity_limit_multiplier);
34430 export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
34431 if(!isWasmInitialized) {
34432 throw new Error("initializeWasm() must be awaited first!");
34434 const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
34435 return nativeResponseValue;
34437 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
34439 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, funding_transaction: number): bigint {
34440 if(!isWasmInitialized) {
34441 throw new Error("initializeWasm() must be awaited first!");
34443 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
34444 return nativeResponseValue;
34446 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_batch_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_ChannelIdPublicKeyZZ temporary_channels, struct LDKTransaction funding_transaction);
34448 export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
34449 if(!isWasmInitialized) {
34450 throw new Error("initializeWasm() must be awaited first!");
34452 const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
34453 return nativeResponseValue;
34455 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_partial_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfigUpdate *NONNULL_PTR config_update);
34457 export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
34458 if(!isWasmInitialized) {
34459 throw new Error("initializeWasm() must be awaited first!");
34461 const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
34462 return nativeResponseValue;
34464 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
34466 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
34467 if(!isWasmInitialized) {
34468 throw new Error("initializeWasm() must be awaited first!");
34470 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
34471 return nativeResponseValue;
34473 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const struct LDKChannelId *NONNULL_PTR next_hop_channel_id, struct LDKPublicKey next_node_id, uint64_t amt_to_forward_msat);
34475 export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: bigint, next_node_id: number, amt_to_forward_msat: bigint): bigint {
34476 if(!isWasmInitialized) {
34477 throw new Error("initializeWasm() must be awaited first!");
34479 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
34480 return nativeResponseValue;
34482 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
34484 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
34485 if(!isWasmInitialized) {
34486 throw new Error("initializeWasm() must be awaited first!");
34488 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
34489 return nativeResponseValue;
34491 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
34493 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
34494 if(!isWasmInitialized) {
34495 throw new Error("initializeWasm() must be awaited first!");
34497 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
34498 // debug statements here
34500 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
34502 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
34503 if(!isWasmInitialized) {
34504 throw new Error("initializeWasm() must be awaited first!");
34506 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
34507 // debug statements here
34509 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
34511 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
34512 if(!isWasmInitialized) {
34513 throw new Error("initializeWasm() must be awaited first!");
34515 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
34516 // debug statements here
34518 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
34520 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
34521 if(!isWasmInitialized) {
34522 throw new Error("initializeWasm() must be awaited first!");
34524 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
34525 // debug statements here
34527 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
34529 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
34530 if(!isWasmInitialized) {
34531 throw new Error("initializeWasm() must be awaited first!");
34533 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
34534 // debug statements here
34536 // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
34538 export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
34539 if(!isWasmInitialized) {
34540 throw new Error("initializeWasm() must be awaited first!");
34542 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
34543 // debug statements here
34545 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
34547 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
34548 if(!isWasmInitialized) {
34549 throw new Error("initializeWasm() must be awaited first!");
34551 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
34552 return nativeResponseValue;
34554 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
34556 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
34557 if(!isWasmInitialized) {
34558 throw new Error("initializeWasm() must be awaited first!");
34560 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
34561 return nativeResponseValue;
34563 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
34565 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
34566 if(!isWasmInitialized) {
34567 throw new Error("initializeWasm() must be awaited first!");
34569 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
34570 return nativeResponseValue;
34572 // MUST_USE_RES struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_offer_builder(const struct LDKChannelManager *NONNULL_PTR this_arg);
34574 export function ChannelManager_create_offer_builder(this_arg: bigint): bigint {
34575 if(!isWasmInitialized) {
34576 throw new Error("initializeWasm() must be awaited first!");
34578 const nativeResponseValue = wasm.TS_ChannelManager_create_offer_builder(this_arg);
34579 return nativeResponseValue;
34581 // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_refund_builder(const struct LDKChannelManager *NONNULL_PTR this_arg, uint64_t amount_msats, uint64_t absolute_expiry, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
34583 export function ChannelManager_create_refund_builder(this_arg: bigint, amount_msats: bigint, absolute_expiry: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
34584 if(!isWasmInitialized) {
34585 throw new Error("initializeWasm() must be awaited first!");
34587 const nativeResponseValue = wasm.TS_ChannelManager_create_refund_builder(this_arg, amount_msats, absolute_expiry, payment_id, retry_strategy, max_total_routing_fee_msat);
34588 return nativeResponseValue;
34590 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ ChannelManager_pay_for_offer(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKOffer *NONNULL_PTR offer, struct LDKCOption_u64Z quantity, struct LDKCOption_u64Z amount_msats, struct LDKCOption_StrZ payer_note, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
34592 export function ChannelManager_pay_for_offer(this_arg: bigint, offer: bigint, quantity: bigint, amount_msats: bigint, payer_note: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
34593 if(!isWasmInitialized) {
34594 throw new Error("initializeWasm() must be awaited first!");
34596 const nativeResponseValue = wasm.TS_ChannelManager_pay_for_offer(this_arg, offer, quantity, amount_msats, payer_note, payment_id, retry_strategy, max_total_routing_fee_msat);
34597 return nativeResponseValue;
34599 // MUST_USE_RES struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ ChannelManager_request_refund_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRefund *NONNULL_PTR refund);
34601 export function ChannelManager_request_refund_payment(this_arg: bigint, refund: bigint): bigint {
34602 if(!isWasmInitialized) {
34603 throw new Error("initializeWasm() must be awaited first!");
34605 const nativeResponseValue = wasm.TS_ChannelManager_request_refund_payment(this_arg, refund);
34606 return nativeResponseValue;
34608 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ ChannelManager_create_inbound_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
34610 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
34611 if(!isWasmInitialized) {
34612 throw new Error("initializeWasm() must be awaited first!");
34614 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
34615 return nativeResponseValue;
34617 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ 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, struct LDKCOption_u16Z min_final_cltv_expiry);
34619 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry: bigint): bigint {
34620 if(!isWasmInitialized) {
34621 throw new Error("initializeWasm() must be awaited first!");
34623 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry);
34624 return nativeResponseValue;
34626 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
34628 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
34629 if(!isWasmInitialized) {
34630 throw new Error("initializeWasm() must be awaited first!");
34632 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
34633 return nativeResponseValue;
34635 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
34637 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
34638 if(!isWasmInitialized) {
34639 throw new Error("initializeWasm() must be awaited first!");
34641 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
34642 return nativeResponseValue;
34644 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
34646 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
34647 if(!isWasmInitialized) {
34648 throw new Error("initializeWasm() must be awaited first!");
34650 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
34651 return nativeResponseValue;
34653 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
34655 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
34656 if(!isWasmInitialized) {
34657 throw new Error("initializeWasm() must be awaited first!");
34659 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
34660 return nativeResponseValue;
34662 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
34664 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
34665 if(!isWasmInitialized) {
34666 throw new Error("initializeWasm() must be awaited first!");
34668 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
34669 return nativeResponseValue;
34671 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
34673 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
34674 if(!isWasmInitialized) {
34675 throw new Error("initializeWasm() must be awaited first!");
34677 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
34678 return nativeResponseValue;
34680 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
34682 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
34683 if(!isWasmInitialized) {
34684 throw new Error("initializeWasm() must be awaited first!");
34686 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
34687 return nativeResponseValue;
34689 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
34691 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
34692 if(!isWasmInitialized) {
34693 throw new Error("initializeWasm() must be awaited first!");
34695 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
34696 return nativeResponseValue;
34698 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
34700 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
34701 if(!isWasmInitialized) {
34702 throw new Error("initializeWasm() must be awaited first!");
34704 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
34705 return nativeResponseValue;
34707 // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
34709 export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
34710 if(!isWasmInitialized) {
34711 throw new Error("initializeWasm() must be awaited first!");
34713 const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
34714 return nativeResponseValue;
34716 // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
34718 export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
34719 if(!isWasmInitialized) {
34720 throw new Error("initializeWasm() must be awaited first!");
34722 const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
34723 return nativeResponseValue;
34725 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
34727 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
34728 if(!isWasmInitialized) {
34729 throw new Error("initializeWasm() must be awaited first!");
34731 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
34732 return nativeResponseValue;
34734 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
34736 export function ChannelManager_node_features(this_arg: bigint): bigint {
34737 if(!isWasmInitialized) {
34738 throw new Error("initializeWasm() must be awaited first!");
34740 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
34741 return nativeResponseValue;
34743 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
34745 export function ChannelManager_channel_features(this_arg: bigint): bigint {
34746 if(!isWasmInitialized) {
34747 throw new Error("initializeWasm() must be awaited first!");
34749 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
34750 return nativeResponseValue;
34752 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
34754 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
34755 if(!isWasmInitialized) {
34756 throw new Error("initializeWasm() must be awaited first!");
34758 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
34759 return nativeResponseValue;
34761 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
34763 export function ChannelManager_init_features(this_arg: bigint): bigint {
34764 if(!isWasmInitialized) {
34765 throw new Error("initializeWasm() must be awaited first!");
34767 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
34768 return nativeResponseValue;
34770 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
34772 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
34773 if(!isWasmInitialized) {
34774 throw new Error("initializeWasm() must be awaited first!");
34776 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
34777 return nativeResponseValue;
34779 // struct LDKOffersMessageHandler ChannelManager_as_OffersMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
34781 export function ChannelManager_as_OffersMessageHandler(this_arg: bigint): bigint {
34782 if(!isWasmInitialized) {
34783 throw new Error("initializeWasm() must be awaited first!");
34785 const nativeResponseValue = wasm.TS_ChannelManager_as_OffersMessageHandler(this_arg);
34786 return nativeResponseValue;
34788 // struct LDKNodeIdLookUp ChannelManager_as_NodeIdLookUp(const struct LDKChannelManager *NONNULL_PTR this_arg);
34790 export function ChannelManager_as_NodeIdLookUp(this_arg: bigint): bigint {
34791 if(!isWasmInitialized) {
34792 throw new Error("initializeWasm() must be awaited first!");
34794 const nativeResponseValue = wasm.TS_ChannelManager_as_NodeIdLookUp(this_arg);
34795 return nativeResponseValue;
34797 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
34799 export function provided_init_features(config: bigint): bigint {
34800 if(!isWasmInitialized) {
34801 throw new Error("initializeWasm() must be awaited first!");
34803 const nativeResponseValue = wasm.TS_provided_init_features(config);
34804 return nativeResponseValue;
34806 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
34808 export function CounterpartyForwardingInfo_write(obj: bigint): number {
34809 if(!isWasmInitialized) {
34810 throw new Error("initializeWasm() must be awaited first!");
34812 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
34813 return nativeResponseValue;
34815 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
34817 export function CounterpartyForwardingInfo_read(ser: number): bigint {
34818 if(!isWasmInitialized) {
34819 throw new Error("initializeWasm() must be awaited first!");
34821 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
34822 return nativeResponseValue;
34824 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
34826 export function ChannelCounterparty_write(obj: bigint): number {
34827 if(!isWasmInitialized) {
34828 throw new Error("initializeWasm() must be awaited first!");
34830 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
34831 return nativeResponseValue;
34833 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
34835 export function ChannelCounterparty_read(ser: number): bigint {
34836 if(!isWasmInitialized) {
34837 throw new Error("initializeWasm() must be awaited first!");
34839 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
34840 return nativeResponseValue;
34842 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
34844 export function ChannelDetails_write(obj: bigint): number {
34845 if(!isWasmInitialized) {
34846 throw new Error("initializeWasm() must be awaited first!");
34848 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
34849 return nativeResponseValue;
34851 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
34853 export function ChannelDetails_read(ser: number): bigint {
34854 if(!isWasmInitialized) {
34855 throw new Error("initializeWasm() must be awaited first!");
34857 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
34858 return nativeResponseValue;
34860 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
34862 export function PhantomRouteHints_write(obj: bigint): number {
34863 if(!isWasmInitialized) {
34864 throw new Error("initializeWasm() must be awaited first!");
34866 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
34867 return nativeResponseValue;
34869 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
34871 export function PhantomRouteHints_read(ser: number): bigint {
34872 if(!isWasmInitialized) {
34873 throw new Error("initializeWasm() must be awaited first!");
34875 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
34876 return nativeResponseValue;
34878 // struct LDKCVec_u8Z BlindedForward_write(const struct LDKBlindedForward *NONNULL_PTR obj);
34880 export function BlindedForward_write(obj: bigint): number {
34881 if(!isWasmInitialized) {
34882 throw new Error("initializeWasm() must be awaited first!");
34884 const nativeResponseValue = wasm.TS_BlindedForward_write(obj);
34885 return nativeResponseValue;
34887 // struct LDKCResult_BlindedForwardDecodeErrorZ BlindedForward_read(struct LDKu8slice ser);
34889 export function BlindedForward_read(ser: number): bigint {
34890 if(!isWasmInitialized) {
34891 throw new Error("initializeWasm() must be awaited first!");
34893 const nativeResponseValue = wasm.TS_BlindedForward_read(ser);
34894 return nativeResponseValue;
34896 // struct LDKCVec_u8Z PendingHTLCRouting_write(const struct LDKPendingHTLCRouting *NONNULL_PTR obj);
34898 export function PendingHTLCRouting_write(obj: bigint): number {
34899 if(!isWasmInitialized) {
34900 throw new Error("initializeWasm() must be awaited first!");
34902 const nativeResponseValue = wasm.TS_PendingHTLCRouting_write(obj);
34903 return nativeResponseValue;
34905 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ PendingHTLCRouting_read(struct LDKu8slice ser);
34907 export function PendingHTLCRouting_read(ser: number): bigint {
34908 if(!isWasmInitialized) {
34909 throw new Error("initializeWasm() must be awaited first!");
34911 const nativeResponseValue = wasm.TS_PendingHTLCRouting_read(ser);
34912 return nativeResponseValue;
34914 // struct LDKCVec_u8Z PendingHTLCInfo_write(const struct LDKPendingHTLCInfo *NONNULL_PTR obj);
34916 export function PendingHTLCInfo_write(obj: bigint): number {
34917 if(!isWasmInitialized) {
34918 throw new Error("initializeWasm() must be awaited first!");
34920 const nativeResponseValue = wasm.TS_PendingHTLCInfo_write(obj);
34921 return nativeResponseValue;
34923 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ PendingHTLCInfo_read(struct LDKu8slice ser);
34925 export function PendingHTLCInfo_read(ser: number): bigint {
34926 if(!isWasmInitialized) {
34927 throw new Error("initializeWasm() must be awaited first!");
34929 const nativeResponseValue = wasm.TS_PendingHTLCInfo_read(ser);
34930 return nativeResponseValue;
34932 // struct LDKCVec_u8Z BlindedFailure_write(const enum LDKBlindedFailure *NONNULL_PTR obj);
34934 export function BlindedFailure_write(obj: bigint): number {
34935 if(!isWasmInitialized) {
34936 throw new Error("initializeWasm() must be awaited first!");
34938 const nativeResponseValue = wasm.TS_BlindedFailure_write(obj);
34939 return nativeResponseValue;
34941 // struct LDKCResult_BlindedFailureDecodeErrorZ BlindedFailure_read(struct LDKu8slice ser);
34943 export function BlindedFailure_read(ser: number): bigint {
34944 if(!isWasmInitialized) {
34945 throw new Error("initializeWasm() must be awaited first!");
34947 const nativeResponseValue = wasm.TS_BlindedFailure_read(ser);
34948 return nativeResponseValue;
34950 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
34952 export function ChannelManager_write(obj: bigint): number {
34953 if(!isWasmInitialized) {
34954 throw new Error("initializeWasm() must be awaited first!");
34956 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
34957 return nativeResponseValue;
34959 // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
34961 export function ChannelShutdownState_write(obj: bigint): number {
34962 if(!isWasmInitialized) {
34963 throw new Error("initializeWasm() must be awaited first!");
34965 const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
34966 return nativeResponseValue;
34968 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
34970 export function ChannelShutdownState_read(ser: number): bigint {
34971 if(!isWasmInitialized) {
34972 throw new Error("initializeWasm() must be awaited first!");
34974 const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
34975 return nativeResponseValue;
34977 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
34979 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
34980 if(!isWasmInitialized) {
34981 throw new Error("initializeWasm() must be awaited first!");
34983 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
34984 // debug statements here
34986 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
34988 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
34989 if(!isWasmInitialized) {
34990 throw new Error("initializeWasm() must be awaited first!");
34992 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
34993 return nativeResponseValue;
34995 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
34997 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
34998 if(!isWasmInitialized) {
34999 throw new Error("initializeWasm() must be awaited first!");
35001 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
35002 // debug statements here
35004 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35006 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
35007 if(!isWasmInitialized) {
35008 throw new Error("initializeWasm() must be awaited first!");
35010 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
35011 return nativeResponseValue;
35013 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
35015 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
35016 if(!isWasmInitialized) {
35017 throw new Error("initializeWasm() must be awaited first!");
35019 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
35020 // debug statements here
35022 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35024 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
35025 if(!isWasmInitialized) {
35026 throw new Error("initializeWasm() must be awaited first!");
35028 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
35029 return nativeResponseValue;
35031 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
35033 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
35034 if(!isWasmInitialized) {
35035 throw new Error("initializeWasm() must be awaited first!");
35037 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
35038 // debug statements here
35040 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35042 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
35043 if(!isWasmInitialized) {
35044 throw new Error("initializeWasm() must be awaited first!");
35046 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
35047 return nativeResponseValue;
35049 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
35051 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
35052 if(!isWasmInitialized) {
35053 throw new Error("initializeWasm() must be awaited first!");
35055 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
35056 // debug statements here
35058 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35060 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
35061 if(!isWasmInitialized) {
35062 throw new Error("initializeWasm() must be awaited first!");
35064 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
35065 return nativeResponseValue;
35067 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
35069 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
35070 if(!isWasmInitialized) {
35071 throw new Error("initializeWasm() must be awaited first!");
35073 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
35074 // debug statements here
35076 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35078 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
35079 if(!isWasmInitialized) {
35080 throw new Error("initializeWasm() must be awaited first!");
35082 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
35083 return nativeResponseValue;
35085 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
35087 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
35088 if(!isWasmInitialized) {
35089 throw new Error("initializeWasm() must be awaited first!");
35091 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
35092 // debug statements here
35094 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35096 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
35097 if(!isWasmInitialized) {
35098 throw new Error("initializeWasm() must be awaited first!");
35100 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
35101 return nativeResponseValue;
35103 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
35105 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
35106 if(!isWasmInitialized) {
35107 throw new Error("initializeWasm() must be awaited first!");
35109 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
35110 // debug statements here
35112 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35114 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
35115 if(!isWasmInitialized) {
35116 throw new Error("initializeWasm() must be awaited first!");
35118 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
35119 return nativeResponseValue;
35121 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
35123 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
35124 if(!isWasmInitialized) {
35125 throw new Error("initializeWasm() must be awaited first!");
35127 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
35128 // debug statements here
35130 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
35132 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
35133 if(!isWasmInitialized) {
35134 throw new Error("initializeWasm() must be awaited first!");
35136 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
35137 return nativeResponseValue;
35139 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
35141 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
35142 if(!isWasmInitialized) {
35143 throw new Error("initializeWasm() must be awaited first!");
35145 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
35146 // debug statements here
35148 // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
35150 export function ChannelManagerReadArgs_new(entropy_source: bigint, node_signer: bigint, signer_provider: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
35151 if(!isWasmInitialized) {
35152 throw new Error("initializeWasm() must be awaited first!");
35154 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
35155 return nativeResponseValue;
35157 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
35159 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
35160 if(!isWasmInitialized) {
35161 throw new Error("initializeWasm() must be awaited first!");
35163 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
35164 return nativeResponseValue;
35166 // void DelayedPaymentBasepoint_free(struct LDKDelayedPaymentBasepoint this_obj);
35168 export function DelayedPaymentBasepoint_free(this_obj: bigint): void {
35169 if(!isWasmInitialized) {
35170 throw new Error("initializeWasm() must be awaited first!");
35172 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_free(this_obj);
35173 // debug statements here
35175 // struct LDKPublicKey DelayedPaymentBasepoint_get_a(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr);
35177 export function DelayedPaymentBasepoint_get_a(this_ptr: bigint): number {
35178 if(!isWasmInitialized) {
35179 throw new Error("initializeWasm() must be awaited first!");
35181 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_get_a(this_ptr);
35182 return nativeResponseValue;
35184 // void DelayedPaymentBasepoint_set_a(struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35186 export function DelayedPaymentBasepoint_set_a(this_ptr: bigint, val: number): void {
35187 if(!isWasmInitialized) {
35188 throw new Error("initializeWasm() must be awaited first!");
35190 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_set_a(this_ptr, val);
35191 // debug statements here
35193 // MUST_USE_RES struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_new(struct LDKPublicKey a_arg);
35195 export function DelayedPaymentBasepoint_new(a_arg: number): bigint {
35196 if(!isWasmInitialized) {
35197 throw new Error("initializeWasm() must be awaited first!");
35199 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_new(a_arg);
35200 return nativeResponseValue;
35202 // bool DelayedPaymentBasepoint_eq(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR a, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR b);
35204 export function DelayedPaymentBasepoint_eq(a: bigint, b: bigint): boolean {
35205 if(!isWasmInitialized) {
35206 throw new Error("initializeWasm() must be awaited first!");
35208 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_eq(a, b);
35209 return nativeResponseValue;
35211 // uint64_t DelayedPaymentBasepoint_clone_ptr(LDKDelayedPaymentBasepoint *NONNULL_PTR arg);
35213 export function DelayedPaymentBasepoint_clone_ptr(arg: bigint): bigint {
35214 if(!isWasmInitialized) {
35215 throw new Error("initializeWasm() must be awaited first!");
35217 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone_ptr(arg);
35218 return nativeResponseValue;
35220 // struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_clone(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR orig);
35222 export function DelayedPaymentBasepoint_clone(orig: bigint): bigint {
35223 if(!isWasmInitialized) {
35224 throw new Error("initializeWasm() must be awaited first!");
35226 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone(orig);
35227 return nativeResponseValue;
35229 // uint64_t DelayedPaymentBasepoint_hash(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR o);
35231 export function DelayedPaymentBasepoint_hash(o: bigint): bigint {
35232 if(!isWasmInitialized) {
35233 throw new Error("initializeWasm() must be awaited first!");
35235 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_hash(o);
35236 return nativeResponseValue;
35238 // MUST_USE_RES struct LDKPublicKey DelayedPaymentBasepoint_to_public_key(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg);
35240 export function DelayedPaymentBasepoint_to_public_key(this_arg: bigint): number {
35241 if(!isWasmInitialized) {
35242 throw new Error("initializeWasm() must be awaited first!");
35244 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_to_public_key(this_arg);
35245 return nativeResponseValue;
35247 // MUST_USE_RES struct LDKThirtyTwoBytes DelayedPaymentBasepoint_derive_add_tweak(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
35249 export function DelayedPaymentBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
35250 if(!isWasmInitialized) {
35251 throw new Error("initializeWasm() must be awaited first!");
35253 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_derive_add_tweak(this_arg, per_commitment_point);
35254 return nativeResponseValue;
35256 // struct LDKCVec_u8Z DelayedPaymentBasepoint_write(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR obj);
35258 export function DelayedPaymentBasepoint_write(obj: bigint): number {
35259 if(!isWasmInitialized) {
35260 throw new Error("initializeWasm() must be awaited first!");
35262 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_write(obj);
35263 return nativeResponseValue;
35265 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ DelayedPaymentBasepoint_read(struct LDKu8slice ser);
35267 export function DelayedPaymentBasepoint_read(ser: number): bigint {
35268 if(!isWasmInitialized) {
35269 throw new Error("initializeWasm() must be awaited first!");
35271 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_read(ser);
35272 return nativeResponseValue;
35274 // void DelayedPaymentKey_free(struct LDKDelayedPaymentKey this_obj);
35276 export function DelayedPaymentKey_free(this_obj: bigint): void {
35277 if(!isWasmInitialized) {
35278 throw new Error("initializeWasm() must be awaited first!");
35280 const nativeResponseValue = wasm.TS_DelayedPaymentKey_free(this_obj);
35281 // debug statements here
35283 // struct LDKPublicKey DelayedPaymentKey_get_a(const struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr);
35285 export function DelayedPaymentKey_get_a(this_ptr: bigint): number {
35286 if(!isWasmInitialized) {
35287 throw new Error("initializeWasm() must be awaited first!");
35289 const nativeResponseValue = wasm.TS_DelayedPaymentKey_get_a(this_ptr);
35290 return nativeResponseValue;
35292 // void DelayedPaymentKey_set_a(struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35294 export function DelayedPaymentKey_set_a(this_ptr: bigint, val: number): void {
35295 if(!isWasmInitialized) {
35296 throw new Error("initializeWasm() must be awaited first!");
35298 const nativeResponseValue = wasm.TS_DelayedPaymentKey_set_a(this_ptr, val);
35299 // debug statements here
35301 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_new(struct LDKPublicKey a_arg);
35303 export function DelayedPaymentKey_new(a_arg: number): bigint {
35304 if(!isWasmInitialized) {
35305 throw new Error("initializeWasm() must be awaited first!");
35307 const nativeResponseValue = wasm.TS_DelayedPaymentKey_new(a_arg);
35308 return nativeResponseValue;
35310 // bool DelayedPaymentKey_eq(const struct LDKDelayedPaymentKey *NONNULL_PTR a, const struct LDKDelayedPaymentKey *NONNULL_PTR b);
35312 export function DelayedPaymentKey_eq(a: bigint, b: bigint): boolean {
35313 if(!isWasmInitialized) {
35314 throw new Error("initializeWasm() must be awaited first!");
35316 const nativeResponseValue = wasm.TS_DelayedPaymentKey_eq(a, b);
35317 return nativeResponseValue;
35319 // uint64_t DelayedPaymentKey_clone_ptr(LDKDelayedPaymentKey *NONNULL_PTR arg);
35321 export function DelayedPaymentKey_clone_ptr(arg: bigint): bigint {
35322 if(!isWasmInitialized) {
35323 throw new Error("initializeWasm() must be awaited first!");
35325 const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone_ptr(arg);
35326 return nativeResponseValue;
35328 // struct LDKDelayedPaymentKey DelayedPaymentKey_clone(const struct LDKDelayedPaymentKey *NONNULL_PTR orig);
35330 export function DelayedPaymentKey_clone(orig: bigint): bigint {
35331 if(!isWasmInitialized) {
35332 throw new Error("initializeWasm() must be awaited first!");
35334 const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone(orig);
35335 return nativeResponseValue;
35337 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_basepoint(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
35339 export function DelayedPaymentKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
35340 if(!isWasmInitialized) {
35341 throw new Error("initializeWasm() must be awaited first!");
35343 const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
35344 return nativeResponseValue;
35346 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_secret_key(const uint8_t (*sk)[32]);
35348 export function DelayedPaymentKey_from_secret_key(sk: number): bigint {
35349 if(!isWasmInitialized) {
35350 throw new Error("initializeWasm() must be awaited first!");
35352 const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_secret_key(sk);
35353 return nativeResponseValue;
35355 // MUST_USE_RES struct LDKPublicKey DelayedPaymentKey_to_public_key(const struct LDKDelayedPaymentKey *NONNULL_PTR this_arg);
35357 export function DelayedPaymentKey_to_public_key(this_arg: bigint): number {
35358 if(!isWasmInitialized) {
35359 throw new Error("initializeWasm() must be awaited first!");
35361 const nativeResponseValue = wasm.TS_DelayedPaymentKey_to_public_key(this_arg);
35362 return nativeResponseValue;
35364 // struct LDKCVec_u8Z DelayedPaymentKey_write(const struct LDKDelayedPaymentKey *NONNULL_PTR obj);
35366 export function DelayedPaymentKey_write(obj: bigint): number {
35367 if(!isWasmInitialized) {
35368 throw new Error("initializeWasm() must be awaited first!");
35370 const nativeResponseValue = wasm.TS_DelayedPaymentKey_write(obj);
35371 return nativeResponseValue;
35373 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ DelayedPaymentKey_read(struct LDKu8slice ser);
35375 export function DelayedPaymentKey_read(ser: number): bigint {
35376 if(!isWasmInitialized) {
35377 throw new Error("initializeWasm() must be awaited first!");
35379 const nativeResponseValue = wasm.TS_DelayedPaymentKey_read(ser);
35380 return nativeResponseValue;
35382 // void HtlcBasepoint_free(struct LDKHtlcBasepoint this_obj);
35384 export function HtlcBasepoint_free(this_obj: bigint): void {
35385 if(!isWasmInitialized) {
35386 throw new Error("initializeWasm() must be awaited first!");
35388 const nativeResponseValue = wasm.TS_HtlcBasepoint_free(this_obj);
35389 // debug statements here
35391 // struct LDKPublicKey HtlcBasepoint_get_a(const struct LDKHtlcBasepoint *NONNULL_PTR this_ptr);
35393 export function HtlcBasepoint_get_a(this_ptr: bigint): number {
35394 if(!isWasmInitialized) {
35395 throw new Error("initializeWasm() must be awaited first!");
35397 const nativeResponseValue = wasm.TS_HtlcBasepoint_get_a(this_ptr);
35398 return nativeResponseValue;
35400 // void HtlcBasepoint_set_a(struct LDKHtlcBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35402 export function HtlcBasepoint_set_a(this_ptr: bigint, val: number): void {
35403 if(!isWasmInitialized) {
35404 throw new Error("initializeWasm() must be awaited first!");
35406 const nativeResponseValue = wasm.TS_HtlcBasepoint_set_a(this_ptr, val);
35407 // debug statements here
35409 // MUST_USE_RES struct LDKHtlcBasepoint HtlcBasepoint_new(struct LDKPublicKey a_arg);
35411 export function HtlcBasepoint_new(a_arg: number): bigint {
35412 if(!isWasmInitialized) {
35413 throw new Error("initializeWasm() must be awaited first!");
35415 const nativeResponseValue = wasm.TS_HtlcBasepoint_new(a_arg);
35416 return nativeResponseValue;
35418 // bool HtlcBasepoint_eq(const struct LDKHtlcBasepoint *NONNULL_PTR a, const struct LDKHtlcBasepoint *NONNULL_PTR b);
35420 export function HtlcBasepoint_eq(a: bigint, b: bigint): boolean {
35421 if(!isWasmInitialized) {
35422 throw new Error("initializeWasm() must be awaited first!");
35424 const nativeResponseValue = wasm.TS_HtlcBasepoint_eq(a, b);
35425 return nativeResponseValue;
35427 // uint64_t HtlcBasepoint_clone_ptr(LDKHtlcBasepoint *NONNULL_PTR arg);
35429 export function HtlcBasepoint_clone_ptr(arg: bigint): bigint {
35430 if(!isWasmInitialized) {
35431 throw new Error("initializeWasm() must be awaited first!");
35433 const nativeResponseValue = wasm.TS_HtlcBasepoint_clone_ptr(arg);
35434 return nativeResponseValue;
35436 // struct LDKHtlcBasepoint HtlcBasepoint_clone(const struct LDKHtlcBasepoint *NONNULL_PTR orig);
35438 export function HtlcBasepoint_clone(orig: bigint): bigint {
35439 if(!isWasmInitialized) {
35440 throw new Error("initializeWasm() must be awaited first!");
35442 const nativeResponseValue = wasm.TS_HtlcBasepoint_clone(orig);
35443 return nativeResponseValue;
35445 // uint64_t HtlcBasepoint_hash(const struct LDKHtlcBasepoint *NONNULL_PTR o);
35447 export function HtlcBasepoint_hash(o: bigint): bigint {
35448 if(!isWasmInitialized) {
35449 throw new Error("initializeWasm() must be awaited first!");
35451 const nativeResponseValue = wasm.TS_HtlcBasepoint_hash(o);
35452 return nativeResponseValue;
35454 // MUST_USE_RES struct LDKPublicKey HtlcBasepoint_to_public_key(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg);
35456 export function HtlcBasepoint_to_public_key(this_arg: bigint): number {
35457 if(!isWasmInitialized) {
35458 throw new Error("initializeWasm() must be awaited first!");
35460 const nativeResponseValue = wasm.TS_HtlcBasepoint_to_public_key(this_arg);
35461 return nativeResponseValue;
35463 // MUST_USE_RES struct LDKThirtyTwoBytes HtlcBasepoint_derive_add_tweak(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
35465 export function HtlcBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
35466 if(!isWasmInitialized) {
35467 throw new Error("initializeWasm() must be awaited first!");
35469 const nativeResponseValue = wasm.TS_HtlcBasepoint_derive_add_tweak(this_arg, per_commitment_point);
35470 return nativeResponseValue;
35472 // struct LDKCVec_u8Z HtlcBasepoint_write(const struct LDKHtlcBasepoint *NONNULL_PTR obj);
35474 export function HtlcBasepoint_write(obj: bigint): number {
35475 if(!isWasmInitialized) {
35476 throw new Error("initializeWasm() must be awaited first!");
35478 const nativeResponseValue = wasm.TS_HtlcBasepoint_write(obj);
35479 return nativeResponseValue;
35481 // struct LDKCResult_HtlcBasepointDecodeErrorZ HtlcBasepoint_read(struct LDKu8slice ser);
35483 export function HtlcBasepoint_read(ser: number): bigint {
35484 if(!isWasmInitialized) {
35485 throw new Error("initializeWasm() must be awaited first!");
35487 const nativeResponseValue = wasm.TS_HtlcBasepoint_read(ser);
35488 return nativeResponseValue;
35490 // void HtlcKey_free(struct LDKHtlcKey this_obj);
35492 export function HtlcKey_free(this_obj: bigint): void {
35493 if(!isWasmInitialized) {
35494 throw new Error("initializeWasm() must be awaited first!");
35496 const nativeResponseValue = wasm.TS_HtlcKey_free(this_obj);
35497 // debug statements here
35499 // struct LDKPublicKey HtlcKey_get_a(const struct LDKHtlcKey *NONNULL_PTR this_ptr);
35501 export function HtlcKey_get_a(this_ptr: bigint): number {
35502 if(!isWasmInitialized) {
35503 throw new Error("initializeWasm() must be awaited first!");
35505 const nativeResponseValue = wasm.TS_HtlcKey_get_a(this_ptr);
35506 return nativeResponseValue;
35508 // void HtlcKey_set_a(struct LDKHtlcKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35510 export function HtlcKey_set_a(this_ptr: bigint, val: number): void {
35511 if(!isWasmInitialized) {
35512 throw new Error("initializeWasm() must be awaited first!");
35514 const nativeResponseValue = wasm.TS_HtlcKey_set_a(this_ptr, val);
35515 // debug statements here
35517 // MUST_USE_RES struct LDKHtlcKey HtlcKey_new(struct LDKPublicKey a_arg);
35519 export function HtlcKey_new(a_arg: number): bigint {
35520 if(!isWasmInitialized) {
35521 throw new Error("initializeWasm() must be awaited first!");
35523 const nativeResponseValue = wasm.TS_HtlcKey_new(a_arg);
35524 return nativeResponseValue;
35526 // bool HtlcKey_eq(const struct LDKHtlcKey *NONNULL_PTR a, const struct LDKHtlcKey *NONNULL_PTR b);
35528 export function HtlcKey_eq(a: bigint, b: bigint): boolean {
35529 if(!isWasmInitialized) {
35530 throw new Error("initializeWasm() must be awaited first!");
35532 const nativeResponseValue = wasm.TS_HtlcKey_eq(a, b);
35533 return nativeResponseValue;
35535 // uint64_t HtlcKey_clone_ptr(LDKHtlcKey *NONNULL_PTR arg);
35537 export function HtlcKey_clone_ptr(arg: bigint): bigint {
35538 if(!isWasmInitialized) {
35539 throw new Error("initializeWasm() must be awaited first!");
35541 const nativeResponseValue = wasm.TS_HtlcKey_clone_ptr(arg);
35542 return nativeResponseValue;
35544 // struct LDKHtlcKey HtlcKey_clone(const struct LDKHtlcKey *NONNULL_PTR orig);
35546 export function HtlcKey_clone(orig: bigint): bigint {
35547 if(!isWasmInitialized) {
35548 throw new Error("initializeWasm() must be awaited first!");
35550 const nativeResponseValue = wasm.TS_HtlcKey_clone(orig);
35551 return nativeResponseValue;
35553 // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_basepoint(const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
35555 export function HtlcKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
35556 if(!isWasmInitialized) {
35557 throw new Error("initializeWasm() must be awaited first!");
35559 const nativeResponseValue = wasm.TS_HtlcKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
35560 return nativeResponseValue;
35562 // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_secret_key(const uint8_t (*sk)[32]);
35564 export function HtlcKey_from_secret_key(sk: number): bigint {
35565 if(!isWasmInitialized) {
35566 throw new Error("initializeWasm() must be awaited first!");
35568 const nativeResponseValue = wasm.TS_HtlcKey_from_secret_key(sk);
35569 return nativeResponseValue;
35571 // MUST_USE_RES struct LDKPublicKey HtlcKey_to_public_key(const struct LDKHtlcKey *NONNULL_PTR this_arg);
35573 export function HtlcKey_to_public_key(this_arg: bigint): number {
35574 if(!isWasmInitialized) {
35575 throw new Error("initializeWasm() must be awaited first!");
35577 const nativeResponseValue = wasm.TS_HtlcKey_to_public_key(this_arg);
35578 return nativeResponseValue;
35580 // struct LDKCVec_u8Z HtlcKey_write(const struct LDKHtlcKey *NONNULL_PTR obj);
35582 export function HtlcKey_write(obj: bigint): number {
35583 if(!isWasmInitialized) {
35584 throw new Error("initializeWasm() must be awaited first!");
35586 const nativeResponseValue = wasm.TS_HtlcKey_write(obj);
35587 return nativeResponseValue;
35589 // struct LDKCResult_HtlcKeyDecodeErrorZ HtlcKey_read(struct LDKu8slice ser);
35591 export function HtlcKey_read(ser: number): bigint {
35592 if(!isWasmInitialized) {
35593 throw new Error("initializeWasm() must be awaited first!");
35595 const nativeResponseValue = wasm.TS_HtlcKey_read(ser);
35596 return nativeResponseValue;
35598 // struct LDKPublicKey add_public_key_tweak(struct LDKPublicKey base_point, const uint8_t (*tweak)[32]);
35600 export function add_public_key_tweak(base_point: number, tweak: number): number {
35601 if(!isWasmInitialized) {
35602 throw new Error("initializeWasm() must be awaited first!");
35604 const nativeResponseValue = wasm.TS_add_public_key_tweak(base_point, tweak);
35605 return nativeResponseValue;
35607 // void RevocationBasepoint_free(struct LDKRevocationBasepoint this_obj);
35609 export function RevocationBasepoint_free(this_obj: bigint): void {
35610 if(!isWasmInitialized) {
35611 throw new Error("initializeWasm() must be awaited first!");
35613 const nativeResponseValue = wasm.TS_RevocationBasepoint_free(this_obj);
35614 // debug statements here
35616 // struct LDKPublicKey RevocationBasepoint_get_a(const struct LDKRevocationBasepoint *NONNULL_PTR this_ptr);
35618 export function RevocationBasepoint_get_a(this_ptr: bigint): number {
35619 if(!isWasmInitialized) {
35620 throw new Error("initializeWasm() must be awaited first!");
35622 const nativeResponseValue = wasm.TS_RevocationBasepoint_get_a(this_ptr);
35623 return nativeResponseValue;
35625 // void RevocationBasepoint_set_a(struct LDKRevocationBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35627 export function RevocationBasepoint_set_a(this_ptr: bigint, val: number): void {
35628 if(!isWasmInitialized) {
35629 throw new Error("initializeWasm() must be awaited first!");
35631 const nativeResponseValue = wasm.TS_RevocationBasepoint_set_a(this_ptr, val);
35632 // debug statements here
35634 // MUST_USE_RES struct LDKRevocationBasepoint RevocationBasepoint_new(struct LDKPublicKey a_arg);
35636 export function RevocationBasepoint_new(a_arg: number): bigint {
35637 if(!isWasmInitialized) {
35638 throw new Error("initializeWasm() must be awaited first!");
35640 const nativeResponseValue = wasm.TS_RevocationBasepoint_new(a_arg);
35641 return nativeResponseValue;
35643 // bool RevocationBasepoint_eq(const struct LDKRevocationBasepoint *NONNULL_PTR a, const struct LDKRevocationBasepoint *NONNULL_PTR b);
35645 export function RevocationBasepoint_eq(a: bigint, b: bigint): boolean {
35646 if(!isWasmInitialized) {
35647 throw new Error("initializeWasm() must be awaited first!");
35649 const nativeResponseValue = wasm.TS_RevocationBasepoint_eq(a, b);
35650 return nativeResponseValue;
35652 // uint64_t RevocationBasepoint_clone_ptr(LDKRevocationBasepoint *NONNULL_PTR arg);
35654 export function RevocationBasepoint_clone_ptr(arg: bigint): bigint {
35655 if(!isWasmInitialized) {
35656 throw new Error("initializeWasm() must be awaited first!");
35658 const nativeResponseValue = wasm.TS_RevocationBasepoint_clone_ptr(arg);
35659 return nativeResponseValue;
35661 // struct LDKRevocationBasepoint RevocationBasepoint_clone(const struct LDKRevocationBasepoint *NONNULL_PTR orig);
35663 export function RevocationBasepoint_clone(orig: bigint): bigint {
35664 if(!isWasmInitialized) {
35665 throw new Error("initializeWasm() must be awaited first!");
35667 const nativeResponseValue = wasm.TS_RevocationBasepoint_clone(orig);
35668 return nativeResponseValue;
35670 // uint64_t RevocationBasepoint_hash(const struct LDKRevocationBasepoint *NONNULL_PTR o);
35672 export function RevocationBasepoint_hash(o: bigint): bigint {
35673 if(!isWasmInitialized) {
35674 throw new Error("initializeWasm() must be awaited first!");
35676 const nativeResponseValue = wasm.TS_RevocationBasepoint_hash(o);
35677 return nativeResponseValue;
35679 // MUST_USE_RES struct LDKPublicKey RevocationBasepoint_to_public_key(const struct LDKRevocationBasepoint *NONNULL_PTR this_arg);
35681 export function RevocationBasepoint_to_public_key(this_arg: bigint): number {
35682 if(!isWasmInitialized) {
35683 throw new Error("initializeWasm() must be awaited first!");
35685 const nativeResponseValue = wasm.TS_RevocationBasepoint_to_public_key(this_arg);
35686 return nativeResponseValue;
35688 // struct LDKCVec_u8Z RevocationBasepoint_write(const struct LDKRevocationBasepoint *NONNULL_PTR obj);
35690 export function RevocationBasepoint_write(obj: bigint): number {
35691 if(!isWasmInitialized) {
35692 throw new Error("initializeWasm() must be awaited first!");
35694 const nativeResponseValue = wasm.TS_RevocationBasepoint_write(obj);
35695 return nativeResponseValue;
35697 // struct LDKCResult_RevocationBasepointDecodeErrorZ RevocationBasepoint_read(struct LDKu8slice ser);
35699 export function RevocationBasepoint_read(ser: number): bigint {
35700 if(!isWasmInitialized) {
35701 throw new Error("initializeWasm() must be awaited first!");
35703 const nativeResponseValue = wasm.TS_RevocationBasepoint_read(ser);
35704 return nativeResponseValue;
35706 // void RevocationKey_free(struct LDKRevocationKey this_obj);
35708 export function RevocationKey_free(this_obj: bigint): void {
35709 if(!isWasmInitialized) {
35710 throw new Error("initializeWasm() must be awaited first!");
35712 const nativeResponseValue = wasm.TS_RevocationKey_free(this_obj);
35713 // debug statements here
35715 // struct LDKPublicKey RevocationKey_get_a(const struct LDKRevocationKey *NONNULL_PTR this_ptr);
35717 export function RevocationKey_get_a(this_ptr: bigint): number {
35718 if(!isWasmInitialized) {
35719 throw new Error("initializeWasm() must be awaited first!");
35721 const nativeResponseValue = wasm.TS_RevocationKey_get_a(this_ptr);
35722 return nativeResponseValue;
35724 // void RevocationKey_set_a(struct LDKRevocationKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35726 export function RevocationKey_set_a(this_ptr: bigint, val: number): void {
35727 if(!isWasmInitialized) {
35728 throw new Error("initializeWasm() must be awaited first!");
35730 const nativeResponseValue = wasm.TS_RevocationKey_set_a(this_ptr, val);
35731 // debug statements here
35733 // MUST_USE_RES struct LDKRevocationKey RevocationKey_new(struct LDKPublicKey a_arg);
35735 export function RevocationKey_new(a_arg: number): bigint {
35736 if(!isWasmInitialized) {
35737 throw new Error("initializeWasm() must be awaited first!");
35739 const nativeResponseValue = wasm.TS_RevocationKey_new(a_arg);
35740 return nativeResponseValue;
35742 // bool RevocationKey_eq(const struct LDKRevocationKey *NONNULL_PTR a, const struct LDKRevocationKey *NONNULL_PTR b);
35744 export function RevocationKey_eq(a: bigint, b: bigint): boolean {
35745 if(!isWasmInitialized) {
35746 throw new Error("initializeWasm() must be awaited first!");
35748 const nativeResponseValue = wasm.TS_RevocationKey_eq(a, b);
35749 return nativeResponseValue;
35751 // uint64_t RevocationKey_clone_ptr(LDKRevocationKey *NONNULL_PTR arg);
35753 export function RevocationKey_clone_ptr(arg: bigint): bigint {
35754 if(!isWasmInitialized) {
35755 throw new Error("initializeWasm() must be awaited first!");
35757 const nativeResponseValue = wasm.TS_RevocationKey_clone_ptr(arg);
35758 return nativeResponseValue;
35760 // struct LDKRevocationKey RevocationKey_clone(const struct LDKRevocationKey *NONNULL_PTR orig);
35762 export function RevocationKey_clone(orig: bigint): bigint {
35763 if(!isWasmInitialized) {
35764 throw new Error("initializeWasm() must be awaited first!");
35766 const nativeResponseValue = wasm.TS_RevocationKey_clone(orig);
35767 return nativeResponseValue;
35769 // uint64_t RevocationKey_hash(const struct LDKRevocationKey *NONNULL_PTR o);
35771 export function RevocationKey_hash(o: bigint): bigint {
35772 if(!isWasmInitialized) {
35773 throw new Error("initializeWasm() must be awaited first!");
35775 const nativeResponseValue = wasm.TS_RevocationKey_hash(o);
35776 return nativeResponseValue;
35778 // MUST_USE_RES struct LDKRevocationKey RevocationKey_from_basepoint(const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
35780 export function RevocationKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
35781 if(!isWasmInitialized) {
35782 throw new Error("initializeWasm() must be awaited first!");
35784 const nativeResponseValue = wasm.TS_RevocationKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
35785 return nativeResponseValue;
35787 // MUST_USE_RES struct LDKPublicKey RevocationKey_to_public_key(const struct LDKRevocationKey *NONNULL_PTR this_arg);
35789 export function RevocationKey_to_public_key(this_arg: bigint): number {
35790 if(!isWasmInitialized) {
35791 throw new Error("initializeWasm() must be awaited first!");
35793 const nativeResponseValue = wasm.TS_RevocationKey_to_public_key(this_arg);
35794 return nativeResponseValue;
35796 // struct LDKCVec_u8Z RevocationKey_write(const struct LDKRevocationKey *NONNULL_PTR obj);
35798 export function RevocationKey_write(obj: bigint): number {
35799 if(!isWasmInitialized) {
35800 throw new Error("initializeWasm() must be awaited first!");
35802 const nativeResponseValue = wasm.TS_RevocationKey_write(obj);
35803 return nativeResponseValue;
35805 // struct LDKCResult_RevocationKeyDecodeErrorZ RevocationKey_read(struct LDKu8slice ser);
35807 export function RevocationKey_read(ser: number): bigint {
35808 if(!isWasmInitialized) {
35809 throw new Error("initializeWasm() must be awaited first!");
35811 const nativeResponseValue = wasm.TS_RevocationKey_read(ser);
35812 return nativeResponseValue;
35814 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
35816 export function ExpandedKey_free(this_obj: bigint): void {
35817 if(!isWasmInitialized) {
35818 throw new Error("initializeWasm() must be awaited first!");
35820 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
35821 // debug statements here
35823 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
35825 export function ExpandedKey_new(key_material: number): bigint {
35826 if(!isWasmInitialized) {
35827 throw new Error("initializeWasm() must be awaited first!");
35829 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
35830 return nativeResponseValue;
35832 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ create(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, const struct LDKEntropySource *NONNULL_PTR entropy_source, uint64_t current_time, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
35834 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, entropy_source: bigint, current_time: bigint, min_final_cltv_expiry_delta: bigint): bigint {
35835 if(!isWasmInitialized) {
35836 throw new Error("initializeWasm() must be awaited first!");
35838 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
35839 return nativeResponseValue;
35841 // struct LDKCResult_ThirtyTwoBytesNoneZ 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
35843 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint, min_final_cltv_expiry_delta: bigint): bigint {
35844 if(!isWasmInitialized) {
35845 throw new Error("initializeWasm() must be awaited first!");
35847 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
35848 return nativeResponseValue;
35850 // void DecodeError_free(struct LDKDecodeError this_ptr);
35852 export function DecodeError_free(this_ptr: bigint): void {
35853 if(!isWasmInitialized) {
35854 throw new Error("initializeWasm() must be awaited first!");
35856 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
35857 // debug statements here
35859 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
35861 export function DecodeError_clone_ptr(arg: bigint): bigint {
35862 if(!isWasmInitialized) {
35863 throw new Error("initializeWasm() must be awaited first!");
35865 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
35866 return nativeResponseValue;
35868 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
35870 export function DecodeError_clone(orig: bigint): bigint {
35871 if(!isWasmInitialized) {
35872 throw new Error("initializeWasm() must be awaited first!");
35874 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
35875 return nativeResponseValue;
35877 // struct LDKDecodeError DecodeError_unknown_version(void);
35879 export function DecodeError_unknown_version(): bigint {
35880 if(!isWasmInitialized) {
35881 throw new Error("initializeWasm() must be awaited first!");
35883 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
35884 return nativeResponseValue;
35886 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
35888 export function DecodeError_unknown_required_feature(): bigint {
35889 if(!isWasmInitialized) {
35890 throw new Error("initializeWasm() must be awaited first!");
35892 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
35893 return nativeResponseValue;
35895 // struct LDKDecodeError DecodeError_invalid_value(void);
35897 export function DecodeError_invalid_value(): bigint {
35898 if(!isWasmInitialized) {
35899 throw new Error("initializeWasm() must be awaited first!");
35901 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
35902 return nativeResponseValue;
35904 // struct LDKDecodeError DecodeError_short_read(void);
35906 export function DecodeError_short_read(): bigint {
35907 if(!isWasmInitialized) {
35908 throw new Error("initializeWasm() must be awaited first!");
35910 const nativeResponseValue = wasm.TS_DecodeError_short_read();
35911 return nativeResponseValue;
35913 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
35915 export function DecodeError_bad_length_descriptor(): bigint {
35916 if(!isWasmInitialized) {
35917 throw new Error("initializeWasm() must be awaited first!");
35919 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
35920 return nativeResponseValue;
35922 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
35924 export function DecodeError_io(a: IOError): bigint {
35925 if(!isWasmInitialized) {
35926 throw new Error("initializeWasm() must be awaited first!");
35928 const nativeResponseValue = wasm.TS_DecodeError_io(a);
35929 return nativeResponseValue;
35931 // struct LDKDecodeError DecodeError_unsupported_compression(void);
35933 export function DecodeError_unsupported_compression(): bigint {
35934 if(!isWasmInitialized) {
35935 throw new Error("initializeWasm() must be awaited first!");
35937 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
35938 return nativeResponseValue;
35940 // struct LDKDecodeError DecodeError_dangerous_value(void);
35942 export function DecodeError_dangerous_value(): bigint {
35943 if(!isWasmInitialized) {
35944 throw new Error("initializeWasm() must be awaited first!");
35946 const nativeResponseValue = wasm.TS_DecodeError_dangerous_value();
35947 return nativeResponseValue;
35949 // uint64_t DecodeError_hash(const struct LDKDecodeError *NONNULL_PTR o);
35951 export function DecodeError_hash(o: bigint): bigint {
35952 if(!isWasmInitialized) {
35953 throw new Error("initializeWasm() must be awaited first!");
35955 const nativeResponseValue = wasm.TS_DecodeError_hash(o);
35956 return nativeResponseValue;
35958 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
35960 export function DecodeError_eq(a: bigint, b: bigint): boolean {
35961 if(!isWasmInitialized) {
35962 throw new Error("initializeWasm() must be awaited first!");
35964 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
35965 return nativeResponseValue;
35967 // void Init_free(struct LDKInit this_obj);
35969 export function Init_free(this_obj: bigint): void {
35970 if(!isWasmInitialized) {
35971 throw new Error("initializeWasm() must be awaited first!");
35973 const nativeResponseValue = wasm.TS_Init_free(this_obj);
35974 // debug statements here
35976 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
35978 export function Init_get_features(this_ptr: bigint): bigint {
35979 if(!isWasmInitialized) {
35980 throw new Error("initializeWasm() must be awaited first!");
35982 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
35983 return nativeResponseValue;
35985 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
35987 export function Init_set_features(this_ptr: bigint, val: bigint): void {
35988 if(!isWasmInitialized) {
35989 throw new Error("initializeWasm() must be awaited first!");
35991 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
35992 // debug statements here
35994 // struct LDKCOption_CVec_ThirtyTwoBytesZZ Init_get_networks(const struct LDKInit *NONNULL_PTR this_ptr);
35996 export function Init_get_networks(this_ptr: bigint): bigint {
35997 if(!isWasmInitialized) {
35998 throw new Error("initializeWasm() must be awaited first!");
36000 const nativeResponseValue = wasm.TS_Init_get_networks(this_ptr);
36001 return nativeResponseValue;
36003 // void Init_set_networks(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_CVec_ThirtyTwoBytesZZ val);
36005 export function Init_set_networks(this_ptr: bigint, val: bigint): void {
36006 if(!isWasmInitialized) {
36007 throw new Error("initializeWasm() must be awaited first!");
36009 const nativeResponseValue = wasm.TS_Init_set_networks(this_ptr, val);
36010 // debug statements here
36012 // struct LDKCOption_SocketAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
36014 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
36015 if(!isWasmInitialized) {
36016 throw new Error("initializeWasm() must be awaited first!");
36018 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
36019 return nativeResponseValue;
36021 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_SocketAddressZ val);
36023 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
36024 if(!isWasmInitialized) {
36025 throw new Error("initializeWasm() must be awaited first!");
36027 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
36028 // debug statements here
36030 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_CVec_ThirtyTwoBytesZZ networks_arg, struct LDKCOption_SocketAddressZ remote_network_address_arg);
36032 export function Init_new(features_arg: bigint, networks_arg: bigint, remote_network_address_arg: bigint): bigint {
36033 if(!isWasmInitialized) {
36034 throw new Error("initializeWasm() must be awaited first!");
36036 const nativeResponseValue = wasm.TS_Init_new(features_arg, networks_arg, remote_network_address_arg);
36037 return nativeResponseValue;
36039 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
36041 export function Init_clone_ptr(arg: bigint): bigint {
36042 if(!isWasmInitialized) {
36043 throw new Error("initializeWasm() must be awaited first!");
36045 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
36046 return nativeResponseValue;
36048 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
36050 export function Init_clone(orig: bigint): bigint {
36051 if(!isWasmInitialized) {
36052 throw new Error("initializeWasm() must be awaited first!");
36054 const nativeResponseValue = wasm.TS_Init_clone(orig);
36055 return nativeResponseValue;
36057 // uint64_t Init_hash(const struct LDKInit *NONNULL_PTR o);
36059 export function Init_hash(o: bigint): bigint {
36060 if(!isWasmInitialized) {
36061 throw new Error("initializeWasm() must be awaited first!");
36063 const nativeResponseValue = wasm.TS_Init_hash(o);
36064 return nativeResponseValue;
36066 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
36068 export function Init_eq(a: bigint, b: bigint): boolean {
36069 if(!isWasmInitialized) {
36070 throw new Error("initializeWasm() must be awaited first!");
36072 const nativeResponseValue = wasm.TS_Init_eq(a, b);
36073 return nativeResponseValue;
36075 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
36077 export function ErrorMessage_free(this_obj: bigint): void {
36078 if(!isWasmInitialized) {
36079 throw new Error("initializeWasm() must be awaited first!");
36081 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
36082 // debug statements here
36084 // struct LDKChannelId ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
36086 export function ErrorMessage_get_channel_id(this_ptr: bigint): bigint {
36087 if(!isWasmInitialized) {
36088 throw new Error("initializeWasm() must be awaited first!");
36090 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
36091 return nativeResponseValue;
36093 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKChannelId val);
36095 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: bigint): void {
36096 if(!isWasmInitialized) {
36097 throw new Error("initializeWasm() must be awaited first!");
36099 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
36100 // debug statements here
36102 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
36104 export function ErrorMessage_get_data(this_ptr: bigint): number {
36105 if(!isWasmInitialized) {
36106 throw new Error("initializeWasm() must be awaited first!");
36108 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
36109 return nativeResponseValue;
36111 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
36113 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
36114 if(!isWasmInitialized) {
36115 throw new Error("initializeWasm() must be awaited first!");
36117 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
36118 // debug statements here
36120 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKChannelId channel_id_arg, struct LDKStr data_arg);
36122 export function ErrorMessage_new(channel_id_arg: bigint, data_arg: number): bigint {
36123 if(!isWasmInitialized) {
36124 throw new Error("initializeWasm() must be awaited first!");
36126 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
36127 return nativeResponseValue;
36129 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
36131 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
36132 if(!isWasmInitialized) {
36133 throw new Error("initializeWasm() must be awaited first!");
36135 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
36136 return nativeResponseValue;
36138 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
36140 export function ErrorMessage_clone(orig: bigint): bigint {
36141 if(!isWasmInitialized) {
36142 throw new Error("initializeWasm() must be awaited first!");
36144 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
36145 return nativeResponseValue;
36147 // uint64_t ErrorMessage_hash(const struct LDKErrorMessage *NONNULL_PTR o);
36149 export function ErrorMessage_hash(o: bigint): bigint {
36150 if(!isWasmInitialized) {
36151 throw new Error("initializeWasm() must be awaited first!");
36153 const nativeResponseValue = wasm.TS_ErrorMessage_hash(o);
36154 return nativeResponseValue;
36156 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
36158 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
36159 if(!isWasmInitialized) {
36160 throw new Error("initializeWasm() must be awaited first!");
36162 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
36163 return nativeResponseValue;
36165 // void WarningMessage_free(struct LDKWarningMessage this_obj);
36167 export function WarningMessage_free(this_obj: bigint): void {
36168 if(!isWasmInitialized) {
36169 throw new Error("initializeWasm() must be awaited first!");
36171 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
36172 // debug statements here
36174 // struct LDKChannelId WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
36176 export function WarningMessage_get_channel_id(this_ptr: bigint): bigint {
36177 if(!isWasmInitialized) {
36178 throw new Error("initializeWasm() must be awaited first!");
36180 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
36181 return nativeResponseValue;
36183 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKChannelId val);
36185 export function WarningMessage_set_channel_id(this_ptr: bigint, val: bigint): void {
36186 if(!isWasmInitialized) {
36187 throw new Error("initializeWasm() must be awaited first!");
36189 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
36190 // debug statements here
36192 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
36194 export function WarningMessage_get_data(this_ptr: bigint): number {
36195 if(!isWasmInitialized) {
36196 throw new Error("initializeWasm() must be awaited first!");
36198 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
36199 return nativeResponseValue;
36201 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
36203 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
36204 if(!isWasmInitialized) {
36205 throw new Error("initializeWasm() must be awaited first!");
36207 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
36208 // debug statements here
36210 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKChannelId channel_id_arg, struct LDKStr data_arg);
36212 export function WarningMessage_new(channel_id_arg: bigint, data_arg: number): bigint {
36213 if(!isWasmInitialized) {
36214 throw new Error("initializeWasm() must be awaited first!");
36216 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
36217 return nativeResponseValue;
36219 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
36221 export function WarningMessage_clone_ptr(arg: bigint): bigint {
36222 if(!isWasmInitialized) {
36223 throw new Error("initializeWasm() must be awaited first!");
36225 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
36226 return nativeResponseValue;
36228 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
36230 export function WarningMessage_clone(orig: bigint): bigint {
36231 if(!isWasmInitialized) {
36232 throw new Error("initializeWasm() must be awaited first!");
36234 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
36235 return nativeResponseValue;
36237 // uint64_t WarningMessage_hash(const struct LDKWarningMessage *NONNULL_PTR o);
36239 export function WarningMessage_hash(o: bigint): bigint {
36240 if(!isWasmInitialized) {
36241 throw new Error("initializeWasm() must be awaited first!");
36243 const nativeResponseValue = wasm.TS_WarningMessage_hash(o);
36244 return nativeResponseValue;
36246 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
36248 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
36249 if(!isWasmInitialized) {
36250 throw new Error("initializeWasm() must be awaited first!");
36252 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
36253 return nativeResponseValue;
36255 // void Ping_free(struct LDKPing this_obj);
36257 export function Ping_free(this_obj: bigint): void {
36258 if(!isWasmInitialized) {
36259 throw new Error("initializeWasm() must be awaited first!");
36261 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
36262 // debug statements here
36264 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
36266 export function Ping_get_ponglen(this_ptr: bigint): number {
36267 if(!isWasmInitialized) {
36268 throw new Error("initializeWasm() must be awaited first!");
36270 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
36271 return nativeResponseValue;
36273 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
36275 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
36276 if(!isWasmInitialized) {
36277 throw new Error("initializeWasm() must be awaited first!");
36279 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
36280 // debug statements here
36282 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
36284 export function Ping_get_byteslen(this_ptr: bigint): number {
36285 if(!isWasmInitialized) {
36286 throw new Error("initializeWasm() must be awaited first!");
36288 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
36289 return nativeResponseValue;
36291 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
36293 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
36294 if(!isWasmInitialized) {
36295 throw new Error("initializeWasm() must be awaited first!");
36297 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
36298 // debug statements here
36300 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
36302 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
36303 if(!isWasmInitialized) {
36304 throw new Error("initializeWasm() must be awaited first!");
36306 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
36307 return nativeResponseValue;
36309 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
36311 export function Ping_clone_ptr(arg: bigint): bigint {
36312 if(!isWasmInitialized) {
36313 throw new Error("initializeWasm() must be awaited first!");
36315 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
36316 return nativeResponseValue;
36318 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
36320 export function Ping_clone(orig: bigint): bigint {
36321 if(!isWasmInitialized) {
36322 throw new Error("initializeWasm() must be awaited first!");
36324 const nativeResponseValue = wasm.TS_Ping_clone(orig);
36325 return nativeResponseValue;
36327 // uint64_t Ping_hash(const struct LDKPing *NONNULL_PTR o);
36329 export function Ping_hash(o: bigint): bigint {
36330 if(!isWasmInitialized) {
36331 throw new Error("initializeWasm() must be awaited first!");
36333 const nativeResponseValue = wasm.TS_Ping_hash(o);
36334 return nativeResponseValue;
36336 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
36338 export function Ping_eq(a: bigint, b: bigint): boolean {
36339 if(!isWasmInitialized) {
36340 throw new Error("initializeWasm() must be awaited first!");
36342 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
36343 return nativeResponseValue;
36345 // void Pong_free(struct LDKPong this_obj);
36347 export function Pong_free(this_obj: bigint): void {
36348 if(!isWasmInitialized) {
36349 throw new Error("initializeWasm() must be awaited first!");
36351 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
36352 // debug statements here
36354 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
36356 export function Pong_get_byteslen(this_ptr: bigint): number {
36357 if(!isWasmInitialized) {
36358 throw new Error("initializeWasm() must be awaited first!");
36360 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
36361 return nativeResponseValue;
36363 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
36365 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
36366 if(!isWasmInitialized) {
36367 throw new Error("initializeWasm() must be awaited first!");
36369 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
36370 // debug statements here
36372 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
36374 export function Pong_new(byteslen_arg: number): bigint {
36375 if(!isWasmInitialized) {
36376 throw new Error("initializeWasm() must be awaited first!");
36378 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
36379 return nativeResponseValue;
36381 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
36383 export function Pong_clone_ptr(arg: bigint): bigint {
36384 if(!isWasmInitialized) {
36385 throw new Error("initializeWasm() must be awaited first!");
36387 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
36388 return nativeResponseValue;
36390 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
36392 export function Pong_clone(orig: bigint): bigint {
36393 if(!isWasmInitialized) {
36394 throw new Error("initializeWasm() must be awaited first!");
36396 const nativeResponseValue = wasm.TS_Pong_clone(orig);
36397 return nativeResponseValue;
36399 // uint64_t Pong_hash(const struct LDKPong *NONNULL_PTR o);
36401 export function Pong_hash(o: bigint): bigint {
36402 if(!isWasmInitialized) {
36403 throw new Error("initializeWasm() must be awaited first!");
36405 const nativeResponseValue = wasm.TS_Pong_hash(o);
36406 return nativeResponseValue;
36408 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
36410 export function Pong_eq(a: bigint, b: bigint): boolean {
36411 if(!isWasmInitialized) {
36412 throw new Error("initializeWasm() must be awaited first!");
36414 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
36415 return nativeResponseValue;
36417 // void CommonOpenChannelFields_free(struct LDKCommonOpenChannelFields this_obj);
36419 export function CommonOpenChannelFields_free(this_obj: bigint): void {
36420 if(!isWasmInitialized) {
36421 throw new Error("initializeWasm() must be awaited first!");
36423 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_free(this_obj);
36424 // debug statements here
36426 // const uint8_t (*CommonOpenChannelFields_get_chain_hash(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr))[32];
36428 export function CommonOpenChannelFields_get_chain_hash(this_ptr: bigint): number {
36429 if(!isWasmInitialized) {
36430 throw new Error("initializeWasm() must be awaited first!");
36432 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_chain_hash(this_ptr);
36433 return nativeResponseValue;
36435 // void CommonOpenChannelFields_set_chain_hash(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36437 export function CommonOpenChannelFields_set_chain_hash(this_ptr: bigint, val: number): void {
36438 if(!isWasmInitialized) {
36439 throw new Error("initializeWasm() must be awaited first!");
36441 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_chain_hash(this_ptr, val);
36442 // debug statements here
36444 // struct LDKChannelId CommonOpenChannelFields_get_temporary_channel_id(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36446 export function CommonOpenChannelFields_get_temporary_channel_id(this_ptr: bigint): bigint {
36447 if(!isWasmInitialized) {
36448 throw new Error("initializeWasm() must be awaited first!");
36450 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_temporary_channel_id(this_ptr);
36451 return nativeResponseValue;
36453 // void CommonOpenChannelFields_set_temporary_channel_id(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKChannelId val);
36455 export function CommonOpenChannelFields_set_temporary_channel_id(this_ptr: bigint, val: bigint): void {
36456 if(!isWasmInitialized) {
36457 throw new Error("initializeWasm() must be awaited first!");
36459 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_temporary_channel_id(this_ptr, val);
36460 // debug statements here
36462 // uint64_t CommonOpenChannelFields_get_funding_satoshis(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36464 export function CommonOpenChannelFields_get_funding_satoshis(this_ptr: bigint): bigint {
36465 if(!isWasmInitialized) {
36466 throw new Error("initializeWasm() must be awaited first!");
36468 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_funding_satoshis(this_ptr);
36469 return nativeResponseValue;
36471 // void CommonOpenChannelFields_set_funding_satoshis(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint64_t val);
36473 export function CommonOpenChannelFields_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
36474 if(!isWasmInitialized) {
36475 throw new Error("initializeWasm() must be awaited first!");
36477 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_funding_satoshis(this_ptr, val);
36478 // debug statements here
36480 // uint64_t CommonOpenChannelFields_get_dust_limit_satoshis(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36482 export function CommonOpenChannelFields_get_dust_limit_satoshis(this_ptr: bigint): bigint {
36483 if(!isWasmInitialized) {
36484 throw new Error("initializeWasm() must be awaited first!");
36486 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_dust_limit_satoshis(this_ptr);
36487 return nativeResponseValue;
36489 // void CommonOpenChannelFields_set_dust_limit_satoshis(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint64_t val);
36491 export function CommonOpenChannelFields_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
36492 if(!isWasmInitialized) {
36493 throw new Error("initializeWasm() must be awaited first!");
36495 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_dust_limit_satoshis(this_ptr, val);
36496 // debug statements here
36498 // uint64_t CommonOpenChannelFields_get_max_htlc_value_in_flight_msat(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36500 export function CommonOpenChannelFields_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
36501 if(!isWasmInitialized) {
36502 throw new Error("initializeWasm() must be awaited first!");
36504 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_max_htlc_value_in_flight_msat(this_ptr);
36505 return nativeResponseValue;
36507 // void CommonOpenChannelFields_set_max_htlc_value_in_flight_msat(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint64_t val);
36509 export function CommonOpenChannelFields_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
36510 if(!isWasmInitialized) {
36511 throw new Error("initializeWasm() must be awaited first!");
36513 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_max_htlc_value_in_flight_msat(this_ptr, val);
36514 // debug statements here
36516 // uint64_t CommonOpenChannelFields_get_htlc_minimum_msat(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36518 export function CommonOpenChannelFields_get_htlc_minimum_msat(this_ptr: bigint): bigint {
36519 if(!isWasmInitialized) {
36520 throw new Error("initializeWasm() must be awaited first!");
36522 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_htlc_minimum_msat(this_ptr);
36523 return nativeResponseValue;
36525 // void CommonOpenChannelFields_set_htlc_minimum_msat(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint64_t val);
36527 export function CommonOpenChannelFields_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
36528 if(!isWasmInitialized) {
36529 throw new Error("initializeWasm() must be awaited first!");
36531 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_htlc_minimum_msat(this_ptr, val);
36532 // debug statements here
36534 // uint32_t CommonOpenChannelFields_get_commitment_feerate_sat_per_1000_weight(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36536 export function CommonOpenChannelFields_get_commitment_feerate_sat_per_1000_weight(this_ptr: bigint): number {
36537 if(!isWasmInitialized) {
36538 throw new Error("initializeWasm() must be awaited first!");
36540 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_commitment_feerate_sat_per_1000_weight(this_ptr);
36541 return nativeResponseValue;
36543 // void CommonOpenChannelFields_set_commitment_feerate_sat_per_1000_weight(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint32_t val);
36545 export function CommonOpenChannelFields_set_commitment_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
36546 if(!isWasmInitialized) {
36547 throw new Error("initializeWasm() must be awaited first!");
36549 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_commitment_feerate_sat_per_1000_weight(this_ptr, val);
36550 // debug statements here
36552 // uint16_t CommonOpenChannelFields_get_to_self_delay(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36554 export function CommonOpenChannelFields_get_to_self_delay(this_ptr: bigint): number {
36555 if(!isWasmInitialized) {
36556 throw new Error("initializeWasm() must be awaited first!");
36558 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_to_self_delay(this_ptr);
36559 return nativeResponseValue;
36561 // void CommonOpenChannelFields_set_to_self_delay(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint16_t val);
36563 export function CommonOpenChannelFields_set_to_self_delay(this_ptr: bigint, val: number): void {
36564 if(!isWasmInitialized) {
36565 throw new Error("initializeWasm() must be awaited first!");
36567 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_to_self_delay(this_ptr, val);
36568 // debug statements here
36570 // uint16_t CommonOpenChannelFields_get_max_accepted_htlcs(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36572 export function CommonOpenChannelFields_get_max_accepted_htlcs(this_ptr: bigint): number {
36573 if(!isWasmInitialized) {
36574 throw new Error("initializeWasm() must be awaited first!");
36576 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_max_accepted_htlcs(this_ptr);
36577 return nativeResponseValue;
36579 // void CommonOpenChannelFields_set_max_accepted_htlcs(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint16_t val);
36581 export function CommonOpenChannelFields_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
36582 if(!isWasmInitialized) {
36583 throw new Error("initializeWasm() must be awaited first!");
36585 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_max_accepted_htlcs(this_ptr, val);
36586 // debug statements here
36588 // struct LDKPublicKey CommonOpenChannelFields_get_funding_pubkey(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36590 export function CommonOpenChannelFields_get_funding_pubkey(this_ptr: bigint): number {
36591 if(!isWasmInitialized) {
36592 throw new Error("initializeWasm() must be awaited first!");
36594 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_funding_pubkey(this_ptr);
36595 return nativeResponseValue;
36597 // void CommonOpenChannelFields_set_funding_pubkey(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36599 export function CommonOpenChannelFields_set_funding_pubkey(this_ptr: bigint, val: number): void {
36600 if(!isWasmInitialized) {
36601 throw new Error("initializeWasm() must be awaited first!");
36603 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_funding_pubkey(this_ptr, val);
36604 // debug statements here
36606 // struct LDKPublicKey CommonOpenChannelFields_get_revocation_basepoint(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36608 export function CommonOpenChannelFields_get_revocation_basepoint(this_ptr: bigint): number {
36609 if(!isWasmInitialized) {
36610 throw new Error("initializeWasm() must be awaited first!");
36612 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_revocation_basepoint(this_ptr);
36613 return nativeResponseValue;
36615 // void CommonOpenChannelFields_set_revocation_basepoint(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36617 export function CommonOpenChannelFields_set_revocation_basepoint(this_ptr: bigint, val: number): void {
36618 if(!isWasmInitialized) {
36619 throw new Error("initializeWasm() must be awaited first!");
36621 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_revocation_basepoint(this_ptr, val);
36622 // debug statements here
36624 // struct LDKPublicKey CommonOpenChannelFields_get_payment_basepoint(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36626 export function CommonOpenChannelFields_get_payment_basepoint(this_ptr: bigint): number {
36627 if(!isWasmInitialized) {
36628 throw new Error("initializeWasm() must be awaited first!");
36630 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_payment_basepoint(this_ptr);
36631 return nativeResponseValue;
36633 // void CommonOpenChannelFields_set_payment_basepoint(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36635 export function CommonOpenChannelFields_set_payment_basepoint(this_ptr: bigint, val: number): void {
36636 if(!isWasmInitialized) {
36637 throw new Error("initializeWasm() must be awaited first!");
36639 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_payment_basepoint(this_ptr, val);
36640 // debug statements here
36642 // struct LDKPublicKey CommonOpenChannelFields_get_delayed_payment_basepoint(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36644 export function CommonOpenChannelFields_get_delayed_payment_basepoint(this_ptr: bigint): number {
36645 if(!isWasmInitialized) {
36646 throw new Error("initializeWasm() must be awaited first!");
36648 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_delayed_payment_basepoint(this_ptr);
36649 return nativeResponseValue;
36651 // void CommonOpenChannelFields_set_delayed_payment_basepoint(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36653 export function CommonOpenChannelFields_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
36654 if(!isWasmInitialized) {
36655 throw new Error("initializeWasm() must be awaited first!");
36657 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_delayed_payment_basepoint(this_ptr, val);
36658 // debug statements here
36660 // struct LDKPublicKey CommonOpenChannelFields_get_htlc_basepoint(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36662 export function CommonOpenChannelFields_get_htlc_basepoint(this_ptr: bigint): number {
36663 if(!isWasmInitialized) {
36664 throw new Error("initializeWasm() must be awaited first!");
36666 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_htlc_basepoint(this_ptr);
36667 return nativeResponseValue;
36669 // void CommonOpenChannelFields_set_htlc_basepoint(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36671 export function CommonOpenChannelFields_set_htlc_basepoint(this_ptr: bigint, val: number): void {
36672 if(!isWasmInitialized) {
36673 throw new Error("initializeWasm() must be awaited first!");
36675 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_htlc_basepoint(this_ptr, val);
36676 // debug statements here
36678 // struct LDKPublicKey CommonOpenChannelFields_get_first_per_commitment_point(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36680 export function CommonOpenChannelFields_get_first_per_commitment_point(this_ptr: bigint): number {
36681 if(!isWasmInitialized) {
36682 throw new Error("initializeWasm() must be awaited first!");
36684 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_first_per_commitment_point(this_ptr);
36685 return nativeResponseValue;
36687 // void CommonOpenChannelFields_set_first_per_commitment_point(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36689 export function CommonOpenChannelFields_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
36690 if(!isWasmInitialized) {
36691 throw new Error("initializeWasm() must be awaited first!");
36693 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_first_per_commitment_point(this_ptr, val);
36694 // debug statements here
36696 // uint8_t CommonOpenChannelFields_get_channel_flags(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36698 export function CommonOpenChannelFields_get_channel_flags(this_ptr: bigint): number {
36699 if(!isWasmInitialized) {
36700 throw new Error("initializeWasm() must be awaited first!");
36702 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_channel_flags(this_ptr);
36703 return nativeResponseValue;
36705 // void CommonOpenChannelFields_set_channel_flags(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, uint8_t val);
36707 export function CommonOpenChannelFields_set_channel_flags(this_ptr: bigint, val: number): void {
36708 if(!isWasmInitialized) {
36709 throw new Error("initializeWasm() must be awaited first!");
36711 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_channel_flags(this_ptr, val);
36712 // debug statements here
36714 // struct LDKCOption_CVec_u8ZZ CommonOpenChannelFields_get_shutdown_scriptpubkey(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36716 export function CommonOpenChannelFields_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
36717 if(!isWasmInitialized) {
36718 throw new Error("initializeWasm() must be awaited first!");
36720 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_shutdown_scriptpubkey(this_ptr);
36721 return nativeResponseValue;
36723 // void CommonOpenChannelFields_set_shutdown_scriptpubkey(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
36725 export function CommonOpenChannelFields_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
36726 if(!isWasmInitialized) {
36727 throw new Error("initializeWasm() must be awaited first!");
36729 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_shutdown_scriptpubkey(this_ptr, val);
36730 // debug statements here
36732 // struct LDKChannelTypeFeatures CommonOpenChannelFields_get_channel_type(const struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr);
36734 export function CommonOpenChannelFields_get_channel_type(this_ptr: bigint): bigint {
36735 if(!isWasmInitialized) {
36736 throw new Error("initializeWasm() must be awaited first!");
36738 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_get_channel_type(this_ptr);
36739 return nativeResponseValue;
36741 // void CommonOpenChannelFields_set_channel_type(struct LDKCommonOpenChannelFields *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
36743 export function CommonOpenChannelFields_set_channel_type(this_ptr: bigint, val: bigint): void {
36744 if(!isWasmInitialized) {
36745 throw new Error("initializeWasm() must be awaited first!");
36747 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_set_channel_type(this_ptr, val);
36748 // debug statements here
36750 // MUST_USE_RES struct LDKCommonOpenChannelFields CommonOpenChannelFields_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKChannelId temporary_channel_id_arg, uint64_t funding_satoshis_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t htlc_minimum_msat_arg, uint32_t commitment_feerate_sat_per_1000_weight_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_basepoint_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg, struct LDKPublicKey first_per_commitment_point_arg, uint8_t channel_flags_arg, struct LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
36752 export function CommonOpenChannelFields_new(chain_hash_arg: number, temporary_channel_id_arg: bigint, funding_satoshis_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, htlc_minimum_msat_arg: bigint, commitment_feerate_sat_per_1000_weight_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_basepoint_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, channel_flags_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint): bigint {
36753 if(!isWasmInitialized) {
36754 throw new Error("initializeWasm() must be awaited first!");
36756 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_new(chain_hash_arg, temporary_channel_id_arg, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, commitment_feerate_sat_per_1000_weight_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_basepoint_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, channel_flags_arg, shutdown_scriptpubkey_arg, channel_type_arg);
36757 return nativeResponseValue;
36759 // uint64_t CommonOpenChannelFields_clone_ptr(LDKCommonOpenChannelFields *NONNULL_PTR arg);
36761 export function CommonOpenChannelFields_clone_ptr(arg: bigint): bigint {
36762 if(!isWasmInitialized) {
36763 throw new Error("initializeWasm() must be awaited first!");
36765 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_clone_ptr(arg);
36766 return nativeResponseValue;
36768 // struct LDKCommonOpenChannelFields CommonOpenChannelFields_clone(const struct LDKCommonOpenChannelFields *NONNULL_PTR orig);
36770 export function CommonOpenChannelFields_clone(orig: bigint): bigint {
36771 if(!isWasmInitialized) {
36772 throw new Error("initializeWasm() must be awaited first!");
36774 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_clone(orig);
36775 return nativeResponseValue;
36777 // uint64_t CommonOpenChannelFields_hash(const struct LDKCommonOpenChannelFields *NONNULL_PTR o);
36779 export function CommonOpenChannelFields_hash(o: bigint): bigint {
36780 if(!isWasmInitialized) {
36781 throw new Error("initializeWasm() must be awaited first!");
36783 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_hash(o);
36784 return nativeResponseValue;
36786 // bool CommonOpenChannelFields_eq(const struct LDKCommonOpenChannelFields *NONNULL_PTR a, const struct LDKCommonOpenChannelFields *NONNULL_PTR b);
36788 export function CommonOpenChannelFields_eq(a: bigint, b: bigint): boolean {
36789 if(!isWasmInitialized) {
36790 throw new Error("initializeWasm() must be awaited first!");
36792 const nativeResponseValue = wasm.TS_CommonOpenChannelFields_eq(a, b);
36793 return nativeResponseValue;
36795 // void OpenChannel_free(struct LDKOpenChannel this_obj);
36797 export function OpenChannel_free(this_obj: bigint): void {
36798 if(!isWasmInitialized) {
36799 throw new Error("initializeWasm() must be awaited first!");
36801 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
36802 // debug statements here
36804 // struct LDKCommonOpenChannelFields OpenChannel_get_common_fields(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
36806 export function OpenChannel_get_common_fields(this_ptr: bigint): bigint {
36807 if(!isWasmInitialized) {
36808 throw new Error("initializeWasm() must be awaited first!");
36810 const nativeResponseValue = wasm.TS_OpenChannel_get_common_fields(this_ptr);
36811 return nativeResponseValue;
36813 // void OpenChannel_set_common_fields(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKCommonOpenChannelFields val);
36815 export function OpenChannel_set_common_fields(this_ptr: bigint, val: bigint): void {
36816 if(!isWasmInitialized) {
36817 throw new Error("initializeWasm() must be awaited first!");
36819 const nativeResponseValue = wasm.TS_OpenChannel_set_common_fields(this_ptr, val);
36820 // debug statements here
36822 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
36824 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
36825 if(!isWasmInitialized) {
36826 throw new Error("initializeWasm() must be awaited first!");
36828 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
36829 return nativeResponseValue;
36831 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
36833 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
36834 if(!isWasmInitialized) {
36835 throw new Error("initializeWasm() must be awaited first!");
36837 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
36838 // debug statements here
36840 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
36842 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
36843 if(!isWasmInitialized) {
36844 throw new Error("initializeWasm() must be awaited first!");
36846 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
36847 return nativeResponseValue;
36849 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
36851 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
36852 if(!isWasmInitialized) {
36853 throw new Error("initializeWasm() must be awaited first!");
36855 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
36856 // debug statements here
36858 // MUST_USE_RES struct LDKOpenChannel OpenChannel_new(struct LDKCommonOpenChannelFields common_fields_arg, uint64_t push_msat_arg, uint64_t channel_reserve_satoshis_arg);
36860 export function OpenChannel_new(common_fields_arg: bigint, push_msat_arg: bigint, channel_reserve_satoshis_arg: bigint): bigint {
36861 if(!isWasmInitialized) {
36862 throw new Error("initializeWasm() must be awaited first!");
36864 const nativeResponseValue = wasm.TS_OpenChannel_new(common_fields_arg, push_msat_arg, channel_reserve_satoshis_arg);
36865 return nativeResponseValue;
36867 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
36869 export function OpenChannel_clone_ptr(arg: bigint): bigint {
36870 if(!isWasmInitialized) {
36871 throw new Error("initializeWasm() must be awaited first!");
36873 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
36874 return nativeResponseValue;
36876 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
36878 export function OpenChannel_clone(orig: bigint): bigint {
36879 if(!isWasmInitialized) {
36880 throw new Error("initializeWasm() must be awaited first!");
36882 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
36883 return nativeResponseValue;
36885 // uint64_t OpenChannel_hash(const struct LDKOpenChannel *NONNULL_PTR o);
36887 export function OpenChannel_hash(o: bigint): bigint {
36888 if(!isWasmInitialized) {
36889 throw new Error("initializeWasm() must be awaited first!");
36891 const nativeResponseValue = wasm.TS_OpenChannel_hash(o);
36892 return nativeResponseValue;
36894 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
36896 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
36897 if(!isWasmInitialized) {
36898 throw new Error("initializeWasm() must be awaited first!");
36900 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
36901 return nativeResponseValue;
36903 // void OpenChannelV2_free(struct LDKOpenChannelV2 this_obj);
36905 export function OpenChannelV2_free(this_obj: bigint): void {
36906 if(!isWasmInitialized) {
36907 throw new Error("initializeWasm() must be awaited first!");
36909 const nativeResponseValue = wasm.TS_OpenChannelV2_free(this_obj);
36910 // debug statements here
36912 // struct LDKCommonOpenChannelFields OpenChannelV2_get_common_fields(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
36914 export function OpenChannelV2_get_common_fields(this_ptr: bigint): bigint {
36915 if(!isWasmInitialized) {
36916 throw new Error("initializeWasm() must be awaited first!");
36918 const nativeResponseValue = wasm.TS_OpenChannelV2_get_common_fields(this_ptr);
36919 return nativeResponseValue;
36921 // void OpenChannelV2_set_common_fields(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKCommonOpenChannelFields val);
36923 export function OpenChannelV2_set_common_fields(this_ptr: bigint, val: bigint): void {
36924 if(!isWasmInitialized) {
36925 throw new Error("initializeWasm() must be awaited first!");
36927 const nativeResponseValue = wasm.TS_OpenChannelV2_set_common_fields(this_ptr, val);
36928 // debug statements here
36930 // uint32_t OpenChannelV2_get_funding_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
36932 export function OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr: bigint): number {
36933 if(!isWasmInitialized) {
36934 throw new Error("initializeWasm() must be awaited first!");
36936 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr);
36937 return nativeResponseValue;
36939 // void OpenChannelV2_set_funding_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
36941 export function OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
36942 if(!isWasmInitialized) {
36943 throw new Error("initializeWasm() must be awaited first!");
36945 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr, val);
36946 // debug statements here
36948 // uint32_t OpenChannelV2_get_locktime(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
36950 export function OpenChannelV2_get_locktime(this_ptr: bigint): number {
36951 if(!isWasmInitialized) {
36952 throw new Error("initializeWasm() must be awaited first!");
36954 const nativeResponseValue = wasm.TS_OpenChannelV2_get_locktime(this_ptr);
36955 return nativeResponseValue;
36957 // void OpenChannelV2_set_locktime(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
36959 export function OpenChannelV2_set_locktime(this_ptr: bigint, val: number): void {
36960 if(!isWasmInitialized) {
36961 throw new Error("initializeWasm() must be awaited first!");
36963 const nativeResponseValue = wasm.TS_OpenChannelV2_set_locktime(this_ptr, val);
36964 // debug statements here
36966 // struct LDKPublicKey OpenChannelV2_get_second_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
36968 export function OpenChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
36969 if(!isWasmInitialized) {
36970 throw new Error("initializeWasm() must be awaited first!");
36972 const nativeResponseValue = wasm.TS_OpenChannelV2_get_second_per_commitment_point(this_ptr);
36973 return nativeResponseValue;
36975 // void OpenChannelV2_set_second_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36977 export function OpenChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
36978 if(!isWasmInitialized) {
36979 throw new Error("initializeWasm() must be awaited first!");
36981 const nativeResponseValue = wasm.TS_OpenChannelV2_set_second_per_commitment_point(this_ptr, val);
36982 // debug statements here
36984 // enum LDKCOption_NoneZ OpenChannelV2_get_require_confirmed_inputs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
36986 export function OpenChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
36987 if(!isWasmInitialized) {
36988 throw new Error("initializeWasm() must be awaited first!");
36990 const nativeResponseValue = wasm.TS_OpenChannelV2_get_require_confirmed_inputs(this_ptr);
36991 return nativeResponseValue;
36993 // void OpenChannelV2_set_require_confirmed_inputs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
36995 export function OpenChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
36996 if(!isWasmInitialized) {
36997 throw new Error("initializeWasm() must be awaited first!");
36999 const nativeResponseValue = wasm.TS_OpenChannelV2_set_require_confirmed_inputs(this_ptr, val);
37000 // debug statements here
37002 // MUST_USE_RES struct LDKOpenChannelV2 OpenChannelV2_new(struct LDKCommonOpenChannelFields common_fields_arg, uint32_t funding_feerate_sat_per_1000_weight_arg, uint32_t locktime_arg, struct LDKPublicKey second_per_commitment_point_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
37004 export function OpenChannelV2_new(common_fields_arg: bigint, funding_feerate_sat_per_1000_weight_arg: number, locktime_arg: number, second_per_commitment_point_arg: number, require_confirmed_inputs_arg: COption_NoneZ): bigint {
37005 if(!isWasmInitialized) {
37006 throw new Error("initializeWasm() must be awaited first!");
37008 const nativeResponseValue = wasm.TS_OpenChannelV2_new(common_fields_arg, funding_feerate_sat_per_1000_weight_arg, locktime_arg, second_per_commitment_point_arg, require_confirmed_inputs_arg);
37009 return nativeResponseValue;
37011 // uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg);
37013 export function OpenChannelV2_clone_ptr(arg: bigint): bigint {
37014 if(!isWasmInitialized) {
37015 throw new Error("initializeWasm() must be awaited first!");
37017 const nativeResponseValue = wasm.TS_OpenChannelV2_clone_ptr(arg);
37018 return nativeResponseValue;
37020 // struct LDKOpenChannelV2 OpenChannelV2_clone(const struct LDKOpenChannelV2 *NONNULL_PTR orig);
37022 export function OpenChannelV2_clone(orig: bigint): bigint {
37023 if(!isWasmInitialized) {
37024 throw new Error("initializeWasm() must be awaited first!");
37026 const nativeResponseValue = wasm.TS_OpenChannelV2_clone(orig);
37027 return nativeResponseValue;
37029 // uint64_t OpenChannelV2_hash(const struct LDKOpenChannelV2 *NONNULL_PTR o);
37031 export function OpenChannelV2_hash(o: bigint): bigint {
37032 if(!isWasmInitialized) {
37033 throw new Error("initializeWasm() must be awaited first!");
37035 const nativeResponseValue = wasm.TS_OpenChannelV2_hash(o);
37036 return nativeResponseValue;
37038 // bool OpenChannelV2_eq(const struct LDKOpenChannelV2 *NONNULL_PTR a, const struct LDKOpenChannelV2 *NONNULL_PTR b);
37040 export function OpenChannelV2_eq(a: bigint, b: bigint): boolean {
37041 if(!isWasmInitialized) {
37042 throw new Error("initializeWasm() must be awaited first!");
37044 const nativeResponseValue = wasm.TS_OpenChannelV2_eq(a, b);
37045 return nativeResponseValue;
37047 // void CommonAcceptChannelFields_free(struct LDKCommonAcceptChannelFields this_obj);
37049 export function CommonAcceptChannelFields_free(this_obj: bigint): void {
37050 if(!isWasmInitialized) {
37051 throw new Error("initializeWasm() must be awaited first!");
37053 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_free(this_obj);
37054 // debug statements here
37056 // struct LDKChannelId CommonAcceptChannelFields_get_temporary_channel_id(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37058 export function CommonAcceptChannelFields_get_temporary_channel_id(this_ptr: bigint): bigint {
37059 if(!isWasmInitialized) {
37060 throw new Error("initializeWasm() must be awaited first!");
37062 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_temporary_channel_id(this_ptr);
37063 return nativeResponseValue;
37065 // void CommonAcceptChannelFields_set_temporary_channel_id(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKChannelId val);
37067 export function CommonAcceptChannelFields_set_temporary_channel_id(this_ptr: bigint, val: bigint): void {
37068 if(!isWasmInitialized) {
37069 throw new Error("initializeWasm() must be awaited first!");
37071 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_temporary_channel_id(this_ptr, val);
37072 // debug statements here
37074 // uint64_t CommonAcceptChannelFields_get_dust_limit_satoshis(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37076 export function CommonAcceptChannelFields_get_dust_limit_satoshis(this_ptr: bigint): bigint {
37077 if(!isWasmInitialized) {
37078 throw new Error("initializeWasm() must be awaited first!");
37080 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_dust_limit_satoshis(this_ptr);
37081 return nativeResponseValue;
37083 // void CommonAcceptChannelFields_set_dust_limit_satoshis(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint64_t val);
37085 export function CommonAcceptChannelFields_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
37086 if(!isWasmInitialized) {
37087 throw new Error("initializeWasm() must be awaited first!");
37089 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_dust_limit_satoshis(this_ptr, val);
37090 // debug statements here
37092 // uint64_t CommonAcceptChannelFields_get_max_htlc_value_in_flight_msat(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37094 export function CommonAcceptChannelFields_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
37095 if(!isWasmInitialized) {
37096 throw new Error("initializeWasm() must be awaited first!");
37098 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_max_htlc_value_in_flight_msat(this_ptr);
37099 return nativeResponseValue;
37101 // void CommonAcceptChannelFields_set_max_htlc_value_in_flight_msat(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint64_t val);
37103 export function CommonAcceptChannelFields_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
37104 if(!isWasmInitialized) {
37105 throw new Error("initializeWasm() must be awaited first!");
37107 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_max_htlc_value_in_flight_msat(this_ptr, val);
37108 // debug statements here
37110 // uint64_t CommonAcceptChannelFields_get_htlc_minimum_msat(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37112 export function CommonAcceptChannelFields_get_htlc_minimum_msat(this_ptr: bigint): bigint {
37113 if(!isWasmInitialized) {
37114 throw new Error("initializeWasm() must be awaited first!");
37116 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_htlc_minimum_msat(this_ptr);
37117 return nativeResponseValue;
37119 // void CommonAcceptChannelFields_set_htlc_minimum_msat(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint64_t val);
37121 export function CommonAcceptChannelFields_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
37122 if(!isWasmInitialized) {
37123 throw new Error("initializeWasm() must be awaited first!");
37125 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_htlc_minimum_msat(this_ptr, val);
37126 // debug statements here
37128 // uint32_t CommonAcceptChannelFields_get_minimum_depth(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37130 export function CommonAcceptChannelFields_get_minimum_depth(this_ptr: bigint): number {
37131 if(!isWasmInitialized) {
37132 throw new Error("initializeWasm() must be awaited first!");
37134 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_minimum_depth(this_ptr);
37135 return nativeResponseValue;
37137 // void CommonAcceptChannelFields_set_minimum_depth(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint32_t val);
37139 export function CommonAcceptChannelFields_set_minimum_depth(this_ptr: bigint, val: number): void {
37140 if(!isWasmInitialized) {
37141 throw new Error("initializeWasm() must be awaited first!");
37143 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_minimum_depth(this_ptr, val);
37144 // debug statements here
37146 // uint16_t CommonAcceptChannelFields_get_to_self_delay(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37148 export function CommonAcceptChannelFields_get_to_self_delay(this_ptr: bigint): number {
37149 if(!isWasmInitialized) {
37150 throw new Error("initializeWasm() must be awaited first!");
37152 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_to_self_delay(this_ptr);
37153 return nativeResponseValue;
37155 // void CommonAcceptChannelFields_set_to_self_delay(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint16_t val);
37157 export function CommonAcceptChannelFields_set_to_self_delay(this_ptr: bigint, val: number): void {
37158 if(!isWasmInitialized) {
37159 throw new Error("initializeWasm() must be awaited first!");
37161 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_to_self_delay(this_ptr, val);
37162 // debug statements here
37164 // uint16_t CommonAcceptChannelFields_get_max_accepted_htlcs(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37166 export function CommonAcceptChannelFields_get_max_accepted_htlcs(this_ptr: bigint): number {
37167 if(!isWasmInitialized) {
37168 throw new Error("initializeWasm() must be awaited first!");
37170 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_max_accepted_htlcs(this_ptr);
37171 return nativeResponseValue;
37173 // void CommonAcceptChannelFields_set_max_accepted_htlcs(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, uint16_t val);
37175 export function CommonAcceptChannelFields_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
37176 if(!isWasmInitialized) {
37177 throw new Error("initializeWasm() must be awaited first!");
37179 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_max_accepted_htlcs(this_ptr, val);
37180 // debug statements here
37182 // struct LDKPublicKey CommonAcceptChannelFields_get_funding_pubkey(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37184 export function CommonAcceptChannelFields_get_funding_pubkey(this_ptr: bigint): number {
37185 if(!isWasmInitialized) {
37186 throw new Error("initializeWasm() must be awaited first!");
37188 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_funding_pubkey(this_ptr);
37189 return nativeResponseValue;
37191 // void CommonAcceptChannelFields_set_funding_pubkey(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37193 export function CommonAcceptChannelFields_set_funding_pubkey(this_ptr: bigint, val: number): void {
37194 if(!isWasmInitialized) {
37195 throw new Error("initializeWasm() must be awaited first!");
37197 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_funding_pubkey(this_ptr, val);
37198 // debug statements here
37200 // struct LDKPublicKey CommonAcceptChannelFields_get_revocation_basepoint(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37202 export function CommonAcceptChannelFields_get_revocation_basepoint(this_ptr: bigint): number {
37203 if(!isWasmInitialized) {
37204 throw new Error("initializeWasm() must be awaited first!");
37206 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_revocation_basepoint(this_ptr);
37207 return nativeResponseValue;
37209 // void CommonAcceptChannelFields_set_revocation_basepoint(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37211 export function CommonAcceptChannelFields_set_revocation_basepoint(this_ptr: bigint, val: number): void {
37212 if(!isWasmInitialized) {
37213 throw new Error("initializeWasm() must be awaited first!");
37215 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_revocation_basepoint(this_ptr, val);
37216 // debug statements here
37218 // struct LDKPublicKey CommonAcceptChannelFields_get_payment_basepoint(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37220 export function CommonAcceptChannelFields_get_payment_basepoint(this_ptr: bigint): number {
37221 if(!isWasmInitialized) {
37222 throw new Error("initializeWasm() must be awaited first!");
37224 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_payment_basepoint(this_ptr);
37225 return nativeResponseValue;
37227 // void CommonAcceptChannelFields_set_payment_basepoint(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37229 export function CommonAcceptChannelFields_set_payment_basepoint(this_ptr: bigint, val: number): void {
37230 if(!isWasmInitialized) {
37231 throw new Error("initializeWasm() must be awaited first!");
37233 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_payment_basepoint(this_ptr, val);
37234 // debug statements here
37236 // struct LDKPublicKey CommonAcceptChannelFields_get_delayed_payment_basepoint(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37238 export function CommonAcceptChannelFields_get_delayed_payment_basepoint(this_ptr: bigint): number {
37239 if(!isWasmInitialized) {
37240 throw new Error("initializeWasm() must be awaited first!");
37242 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_delayed_payment_basepoint(this_ptr);
37243 return nativeResponseValue;
37245 // void CommonAcceptChannelFields_set_delayed_payment_basepoint(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37247 export function CommonAcceptChannelFields_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
37248 if(!isWasmInitialized) {
37249 throw new Error("initializeWasm() must be awaited first!");
37251 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_delayed_payment_basepoint(this_ptr, val);
37252 // debug statements here
37254 // struct LDKPublicKey CommonAcceptChannelFields_get_htlc_basepoint(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37256 export function CommonAcceptChannelFields_get_htlc_basepoint(this_ptr: bigint): number {
37257 if(!isWasmInitialized) {
37258 throw new Error("initializeWasm() must be awaited first!");
37260 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_htlc_basepoint(this_ptr);
37261 return nativeResponseValue;
37263 // void CommonAcceptChannelFields_set_htlc_basepoint(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37265 export function CommonAcceptChannelFields_set_htlc_basepoint(this_ptr: bigint, val: number): void {
37266 if(!isWasmInitialized) {
37267 throw new Error("initializeWasm() must be awaited first!");
37269 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_htlc_basepoint(this_ptr, val);
37270 // debug statements here
37272 // struct LDKPublicKey CommonAcceptChannelFields_get_first_per_commitment_point(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37274 export function CommonAcceptChannelFields_get_first_per_commitment_point(this_ptr: bigint): number {
37275 if(!isWasmInitialized) {
37276 throw new Error("initializeWasm() must be awaited first!");
37278 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_first_per_commitment_point(this_ptr);
37279 return nativeResponseValue;
37281 // void CommonAcceptChannelFields_set_first_per_commitment_point(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37283 export function CommonAcceptChannelFields_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
37284 if(!isWasmInitialized) {
37285 throw new Error("initializeWasm() must be awaited first!");
37287 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_first_per_commitment_point(this_ptr, val);
37288 // debug statements here
37290 // struct LDKCOption_CVec_u8ZZ CommonAcceptChannelFields_get_shutdown_scriptpubkey(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37292 export function CommonAcceptChannelFields_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
37293 if(!isWasmInitialized) {
37294 throw new Error("initializeWasm() must be awaited first!");
37296 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_shutdown_scriptpubkey(this_ptr);
37297 return nativeResponseValue;
37299 // void CommonAcceptChannelFields_set_shutdown_scriptpubkey(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
37301 export function CommonAcceptChannelFields_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
37302 if(!isWasmInitialized) {
37303 throw new Error("initializeWasm() must be awaited first!");
37305 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_shutdown_scriptpubkey(this_ptr, val);
37306 // debug statements here
37308 // struct LDKChannelTypeFeatures CommonAcceptChannelFields_get_channel_type(const struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr);
37310 export function CommonAcceptChannelFields_get_channel_type(this_ptr: bigint): bigint {
37311 if(!isWasmInitialized) {
37312 throw new Error("initializeWasm() must be awaited first!");
37314 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_get_channel_type(this_ptr);
37315 return nativeResponseValue;
37317 // void CommonAcceptChannelFields_set_channel_type(struct LDKCommonAcceptChannelFields *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
37319 export function CommonAcceptChannelFields_set_channel_type(this_ptr: bigint, val: bigint): void {
37320 if(!isWasmInitialized) {
37321 throw new Error("initializeWasm() must be awaited first!");
37323 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_set_channel_type(this_ptr, val);
37324 // debug statements here
37326 // MUST_USE_RES struct LDKCommonAcceptChannelFields CommonAcceptChannelFields_new(struct LDKChannelId temporary_channel_id_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t htlc_minimum_msat_arg, uint32_t minimum_depth_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_basepoint_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg, struct LDKPublicKey first_per_commitment_point_arg, struct LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
37328 export function CommonAcceptChannelFields_new(temporary_channel_id_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, htlc_minimum_msat_arg: bigint, minimum_depth_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_basepoint_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint): bigint {
37329 if(!isWasmInitialized) {
37330 throw new Error("initializeWasm() must be awaited first!");
37332 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_new(temporary_channel_id_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_basepoint_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, shutdown_scriptpubkey_arg, channel_type_arg);
37333 return nativeResponseValue;
37335 // uint64_t CommonAcceptChannelFields_clone_ptr(LDKCommonAcceptChannelFields *NONNULL_PTR arg);
37337 export function CommonAcceptChannelFields_clone_ptr(arg: bigint): bigint {
37338 if(!isWasmInitialized) {
37339 throw new Error("initializeWasm() must be awaited first!");
37341 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_clone_ptr(arg);
37342 return nativeResponseValue;
37344 // struct LDKCommonAcceptChannelFields CommonAcceptChannelFields_clone(const struct LDKCommonAcceptChannelFields *NONNULL_PTR orig);
37346 export function CommonAcceptChannelFields_clone(orig: bigint): bigint {
37347 if(!isWasmInitialized) {
37348 throw new Error("initializeWasm() must be awaited first!");
37350 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_clone(orig);
37351 return nativeResponseValue;
37353 // uint64_t CommonAcceptChannelFields_hash(const struct LDKCommonAcceptChannelFields *NONNULL_PTR o);
37355 export function CommonAcceptChannelFields_hash(o: bigint): bigint {
37356 if(!isWasmInitialized) {
37357 throw new Error("initializeWasm() must be awaited first!");
37359 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_hash(o);
37360 return nativeResponseValue;
37362 // bool CommonAcceptChannelFields_eq(const struct LDKCommonAcceptChannelFields *NONNULL_PTR a, const struct LDKCommonAcceptChannelFields *NONNULL_PTR b);
37364 export function CommonAcceptChannelFields_eq(a: bigint, b: bigint): boolean {
37365 if(!isWasmInitialized) {
37366 throw new Error("initializeWasm() must be awaited first!");
37368 const nativeResponseValue = wasm.TS_CommonAcceptChannelFields_eq(a, b);
37369 return nativeResponseValue;
37371 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
37373 export function AcceptChannel_free(this_obj: bigint): void {
37374 if(!isWasmInitialized) {
37375 throw new Error("initializeWasm() must be awaited first!");
37377 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
37378 // debug statements here
37380 // struct LDKCommonAcceptChannelFields AcceptChannel_get_common_fields(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
37382 export function AcceptChannel_get_common_fields(this_ptr: bigint): bigint {
37383 if(!isWasmInitialized) {
37384 throw new Error("initializeWasm() must be awaited first!");
37386 const nativeResponseValue = wasm.TS_AcceptChannel_get_common_fields(this_ptr);
37387 return nativeResponseValue;
37389 // void AcceptChannel_set_common_fields(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKCommonAcceptChannelFields val);
37391 export function AcceptChannel_set_common_fields(this_ptr: bigint, val: bigint): void {
37392 if(!isWasmInitialized) {
37393 throw new Error("initializeWasm() must be awaited first!");
37395 const nativeResponseValue = wasm.TS_AcceptChannel_set_common_fields(this_ptr, val);
37396 // debug statements here
37398 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
37400 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
37401 if(!isWasmInitialized) {
37402 throw new Error("initializeWasm() must be awaited first!");
37404 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
37405 return nativeResponseValue;
37407 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
37409 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
37410 if(!isWasmInitialized) {
37411 throw new Error("initializeWasm() must be awaited first!");
37413 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
37414 // debug statements here
37416 // MUST_USE_RES struct LDKAcceptChannel AcceptChannel_new(struct LDKCommonAcceptChannelFields common_fields_arg, uint64_t channel_reserve_satoshis_arg);
37418 export function AcceptChannel_new(common_fields_arg: bigint, channel_reserve_satoshis_arg: bigint): bigint {
37419 if(!isWasmInitialized) {
37420 throw new Error("initializeWasm() must be awaited first!");
37422 const nativeResponseValue = wasm.TS_AcceptChannel_new(common_fields_arg, channel_reserve_satoshis_arg);
37423 return nativeResponseValue;
37425 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
37427 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
37428 if(!isWasmInitialized) {
37429 throw new Error("initializeWasm() must be awaited first!");
37431 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
37432 return nativeResponseValue;
37434 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
37436 export function AcceptChannel_clone(orig: bigint): bigint {
37437 if(!isWasmInitialized) {
37438 throw new Error("initializeWasm() must be awaited first!");
37440 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
37441 return nativeResponseValue;
37443 // uint64_t AcceptChannel_hash(const struct LDKAcceptChannel *NONNULL_PTR o);
37445 export function AcceptChannel_hash(o: bigint): bigint {
37446 if(!isWasmInitialized) {
37447 throw new Error("initializeWasm() must be awaited first!");
37449 const nativeResponseValue = wasm.TS_AcceptChannel_hash(o);
37450 return nativeResponseValue;
37452 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
37454 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
37455 if(!isWasmInitialized) {
37456 throw new Error("initializeWasm() must be awaited first!");
37458 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
37459 return nativeResponseValue;
37461 // void AcceptChannelV2_free(struct LDKAcceptChannelV2 this_obj);
37463 export function AcceptChannelV2_free(this_obj: bigint): void {
37464 if(!isWasmInitialized) {
37465 throw new Error("initializeWasm() must be awaited first!");
37467 const nativeResponseValue = wasm.TS_AcceptChannelV2_free(this_obj);
37468 // debug statements here
37470 // struct LDKCommonAcceptChannelFields AcceptChannelV2_get_common_fields(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
37472 export function AcceptChannelV2_get_common_fields(this_ptr: bigint): bigint {
37473 if(!isWasmInitialized) {
37474 throw new Error("initializeWasm() must be awaited first!");
37476 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_common_fields(this_ptr);
37477 return nativeResponseValue;
37479 // void AcceptChannelV2_set_common_fields(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKCommonAcceptChannelFields val);
37481 export function AcceptChannelV2_set_common_fields(this_ptr: bigint, val: bigint): void {
37482 if(!isWasmInitialized) {
37483 throw new Error("initializeWasm() must be awaited first!");
37485 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_common_fields(this_ptr, val);
37486 // debug statements here
37488 // uint64_t AcceptChannelV2_get_funding_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
37490 export function AcceptChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
37491 if(!isWasmInitialized) {
37492 throw new Error("initializeWasm() must be awaited first!");
37494 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_satoshis(this_ptr);
37495 return nativeResponseValue;
37497 // void AcceptChannelV2_set_funding_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
37499 export function AcceptChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
37500 if(!isWasmInitialized) {
37501 throw new Error("initializeWasm() must be awaited first!");
37503 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_satoshis(this_ptr, val);
37504 // debug statements here
37506 // struct LDKPublicKey AcceptChannelV2_get_second_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
37508 export function AcceptChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
37509 if(!isWasmInitialized) {
37510 throw new Error("initializeWasm() must be awaited first!");
37512 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_second_per_commitment_point(this_ptr);
37513 return nativeResponseValue;
37515 // void AcceptChannelV2_set_second_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37517 export function AcceptChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
37518 if(!isWasmInitialized) {
37519 throw new Error("initializeWasm() must be awaited first!");
37521 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_second_per_commitment_point(this_ptr, val);
37522 // debug statements here
37524 // enum LDKCOption_NoneZ AcceptChannelV2_get_require_confirmed_inputs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
37526 export function AcceptChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
37527 if(!isWasmInitialized) {
37528 throw new Error("initializeWasm() must be awaited first!");
37530 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_require_confirmed_inputs(this_ptr);
37531 return nativeResponseValue;
37533 // void AcceptChannelV2_set_require_confirmed_inputs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
37535 export function AcceptChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
37536 if(!isWasmInitialized) {
37537 throw new Error("initializeWasm() must be awaited first!");
37539 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_require_confirmed_inputs(this_ptr, val);
37540 // debug statements here
37542 // MUST_USE_RES struct LDKAcceptChannelV2 AcceptChannelV2_new(struct LDKCommonAcceptChannelFields common_fields_arg, uint64_t funding_satoshis_arg, struct LDKPublicKey second_per_commitment_point_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
37544 export function AcceptChannelV2_new(common_fields_arg: bigint, funding_satoshis_arg: bigint, second_per_commitment_point_arg: number, require_confirmed_inputs_arg: COption_NoneZ): bigint {
37545 if(!isWasmInitialized) {
37546 throw new Error("initializeWasm() must be awaited first!");
37548 const nativeResponseValue = wasm.TS_AcceptChannelV2_new(common_fields_arg, funding_satoshis_arg, second_per_commitment_point_arg, require_confirmed_inputs_arg);
37549 return nativeResponseValue;
37551 // uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg);
37553 export function AcceptChannelV2_clone_ptr(arg: bigint): bigint {
37554 if(!isWasmInitialized) {
37555 throw new Error("initializeWasm() must be awaited first!");
37557 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone_ptr(arg);
37558 return nativeResponseValue;
37560 // struct LDKAcceptChannelV2 AcceptChannelV2_clone(const struct LDKAcceptChannelV2 *NONNULL_PTR orig);
37562 export function AcceptChannelV2_clone(orig: bigint): bigint {
37563 if(!isWasmInitialized) {
37564 throw new Error("initializeWasm() must be awaited first!");
37566 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone(orig);
37567 return nativeResponseValue;
37569 // uint64_t AcceptChannelV2_hash(const struct LDKAcceptChannelV2 *NONNULL_PTR o);
37571 export function AcceptChannelV2_hash(o: bigint): bigint {
37572 if(!isWasmInitialized) {
37573 throw new Error("initializeWasm() must be awaited first!");
37575 const nativeResponseValue = wasm.TS_AcceptChannelV2_hash(o);
37576 return nativeResponseValue;
37578 // bool AcceptChannelV2_eq(const struct LDKAcceptChannelV2 *NONNULL_PTR a, const struct LDKAcceptChannelV2 *NONNULL_PTR b);
37580 export function AcceptChannelV2_eq(a: bigint, b: bigint): boolean {
37581 if(!isWasmInitialized) {
37582 throw new Error("initializeWasm() must be awaited first!");
37584 const nativeResponseValue = wasm.TS_AcceptChannelV2_eq(a, b);
37585 return nativeResponseValue;
37587 // void FundingCreated_free(struct LDKFundingCreated this_obj);
37589 export function FundingCreated_free(this_obj: bigint): void {
37590 if(!isWasmInitialized) {
37591 throw new Error("initializeWasm() must be awaited first!");
37593 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
37594 // debug statements here
37596 // struct LDKChannelId FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
37598 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): bigint {
37599 if(!isWasmInitialized) {
37600 throw new Error("initializeWasm() must be awaited first!");
37602 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
37603 return nativeResponseValue;
37605 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKChannelId val);
37607 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: bigint): void {
37608 if(!isWasmInitialized) {
37609 throw new Error("initializeWasm() must be awaited first!");
37611 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
37612 // debug statements here
37614 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
37616 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
37617 if(!isWasmInitialized) {
37618 throw new Error("initializeWasm() must be awaited first!");
37620 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
37621 return nativeResponseValue;
37623 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37625 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
37626 if(!isWasmInitialized) {
37627 throw new Error("initializeWasm() must be awaited first!");
37629 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
37630 // debug statements here
37632 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
37634 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
37635 if(!isWasmInitialized) {
37636 throw new Error("initializeWasm() must be awaited first!");
37638 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
37639 return nativeResponseValue;
37641 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
37643 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
37644 if(!isWasmInitialized) {
37645 throw new Error("initializeWasm() must be awaited first!");
37647 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
37648 // debug statements here
37650 // struct LDKECDSASignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
37652 export function FundingCreated_get_signature(this_ptr: bigint): number {
37653 if(!isWasmInitialized) {
37654 throw new Error("initializeWasm() must be awaited first!");
37656 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
37657 return nativeResponseValue;
37659 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37661 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
37662 if(!isWasmInitialized) {
37663 throw new Error("initializeWasm() must be awaited first!");
37665 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
37666 // debug statements here
37668 // MUST_USE_RES struct LDKFundingCreated FundingCreated_new(struct LDKChannelId temporary_channel_id_arg, struct LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, struct LDKECDSASignature signature_arg);
37670 export function FundingCreated_new(temporary_channel_id_arg: bigint, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
37671 if(!isWasmInitialized) {
37672 throw new Error("initializeWasm() must be awaited first!");
37674 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
37675 return nativeResponseValue;
37677 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
37679 export function FundingCreated_clone_ptr(arg: bigint): bigint {
37680 if(!isWasmInitialized) {
37681 throw new Error("initializeWasm() must be awaited first!");
37683 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
37684 return nativeResponseValue;
37686 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
37688 export function FundingCreated_clone(orig: bigint): bigint {
37689 if(!isWasmInitialized) {
37690 throw new Error("initializeWasm() must be awaited first!");
37692 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
37693 return nativeResponseValue;
37695 // uint64_t FundingCreated_hash(const struct LDKFundingCreated *NONNULL_PTR o);
37697 export function FundingCreated_hash(o: bigint): bigint {
37698 if(!isWasmInitialized) {
37699 throw new Error("initializeWasm() must be awaited first!");
37701 const nativeResponseValue = wasm.TS_FundingCreated_hash(o);
37702 return nativeResponseValue;
37704 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
37706 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
37707 if(!isWasmInitialized) {
37708 throw new Error("initializeWasm() must be awaited first!");
37710 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
37711 return nativeResponseValue;
37713 // void FundingSigned_free(struct LDKFundingSigned this_obj);
37715 export function FundingSigned_free(this_obj: bigint): void {
37716 if(!isWasmInitialized) {
37717 throw new Error("initializeWasm() must be awaited first!");
37719 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
37720 // debug statements here
37722 // struct LDKChannelId FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
37724 export function FundingSigned_get_channel_id(this_ptr: bigint): bigint {
37725 if(!isWasmInitialized) {
37726 throw new Error("initializeWasm() must be awaited first!");
37728 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
37729 return nativeResponseValue;
37731 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKChannelId val);
37733 export function FundingSigned_set_channel_id(this_ptr: bigint, val: bigint): void {
37734 if(!isWasmInitialized) {
37735 throw new Error("initializeWasm() must be awaited first!");
37737 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
37738 // debug statements here
37740 // struct LDKECDSASignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
37742 export function FundingSigned_get_signature(this_ptr: bigint): number {
37743 if(!isWasmInitialized) {
37744 throw new Error("initializeWasm() must be awaited first!");
37746 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
37747 return nativeResponseValue;
37749 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37751 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
37752 if(!isWasmInitialized) {
37753 throw new Error("initializeWasm() must be awaited first!");
37755 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
37756 // debug statements here
37758 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKChannelId channel_id_arg, struct LDKECDSASignature signature_arg);
37760 export function FundingSigned_new(channel_id_arg: bigint, signature_arg: number): bigint {
37761 if(!isWasmInitialized) {
37762 throw new Error("initializeWasm() must be awaited first!");
37764 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
37765 return nativeResponseValue;
37767 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
37769 export function FundingSigned_clone_ptr(arg: bigint): bigint {
37770 if(!isWasmInitialized) {
37771 throw new Error("initializeWasm() must be awaited first!");
37773 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
37774 return nativeResponseValue;
37776 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
37778 export function FundingSigned_clone(orig: bigint): bigint {
37779 if(!isWasmInitialized) {
37780 throw new Error("initializeWasm() must be awaited first!");
37782 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
37783 return nativeResponseValue;
37785 // uint64_t FundingSigned_hash(const struct LDKFundingSigned *NONNULL_PTR o);
37787 export function FundingSigned_hash(o: bigint): bigint {
37788 if(!isWasmInitialized) {
37789 throw new Error("initializeWasm() must be awaited first!");
37791 const nativeResponseValue = wasm.TS_FundingSigned_hash(o);
37792 return nativeResponseValue;
37794 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
37796 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
37797 if(!isWasmInitialized) {
37798 throw new Error("initializeWasm() must be awaited first!");
37800 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
37801 return nativeResponseValue;
37803 // void ChannelReady_free(struct LDKChannelReady this_obj);
37805 export function ChannelReady_free(this_obj: bigint): void {
37806 if(!isWasmInitialized) {
37807 throw new Error("initializeWasm() must be awaited first!");
37809 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
37810 // debug statements here
37812 // struct LDKChannelId ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr);
37814 export function ChannelReady_get_channel_id(this_ptr: bigint): bigint {
37815 if(!isWasmInitialized) {
37816 throw new Error("initializeWasm() must be awaited first!");
37818 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
37819 return nativeResponseValue;
37821 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKChannelId val);
37823 export function ChannelReady_set_channel_id(this_ptr: bigint, val: bigint): void {
37824 if(!isWasmInitialized) {
37825 throw new Error("initializeWasm() must be awaited first!");
37827 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
37828 // debug statements here
37830 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
37832 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
37833 if(!isWasmInitialized) {
37834 throw new Error("initializeWasm() must be awaited first!");
37836 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
37837 return nativeResponseValue;
37839 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37841 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
37842 if(!isWasmInitialized) {
37843 throw new Error("initializeWasm() must be awaited first!");
37845 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
37846 // debug statements here
37848 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
37850 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
37851 if(!isWasmInitialized) {
37852 throw new Error("initializeWasm() must be awaited first!");
37854 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
37855 return nativeResponseValue;
37857 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
37859 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
37860 if(!isWasmInitialized) {
37861 throw new Error("initializeWasm() must be awaited first!");
37863 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
37864 // debug statements here
37866 // MUST_USE_RES struct LDKChannelReady ChannelReady_new(struct LDKChannelId channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg, struct LDKCOption_u64Z short_channel_id_alias_arg);
37868 export function ChannelReady_new(channel_id_arg: bigint, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
37869 if(!isWasmInitialized) {
37870 throw new Error("initializeWasm() must be awaited first!");
37872 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
37873 return nativeResponseValue;
37875 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
37877 export function ChannelReady_clone_ptr(arg: bigint): bigint {
37878 if(!isWasmInitialized) {
37879 throw new Error("initializeWasm() must be awaited first!");
37881 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
37882 return nativeResponseValue;
37884 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
37886 export function ChannelReady_clone(orig: bigint): bigint {
37887 if(!isWasmInitialized) {
37888 throw new Error("initializeWasm() must be awaited first!");
37890 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
37891 return nativeResponseValue;
37893 // uint64_t ChannelReady_hash(const struct LDKChannelReady *NONNULL_PTR o);
37895 export function ChannelReady_hash(o: bigint): bigint {
37896 if(!isWasmInitialized) {
37897 throw new Error("initializeWasm() must be awaited first!");
37899 const nativeResponseValue = wasm.TS_ChannelReady_hash(o);
37900 return nativeResponseValue;
37902 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
37904 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
37905 if(!isWasmInitialized) {
37906 throw new Error("initializeWasm() must be awaited first!");
37908 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
37909 return nativeResponseValue;
37911 // void Stfu_free(struct LDKStfu this_obj);
37913 export function Stfu_free(this_obj: bigint): void {
37914 if(!isWasmInitialized) {
37915 throw new Error("initializeWasm() must be awaited first!");
37917 const nativeResponseValue = wasm.TS_Stfu_free(this_obj);
37918 // debug statements here
37920 // struct LDKChannelId Stfu_get_channel_id(const struct LDKStfu *NONNULL_PTR this_ptr);
37922 export function Stfu_get_channel_id(this_ptr: bigint): bigint {
37923 if(!isWasmInitialized) {
37924 throw new Error("initializeWasm() must be awaited first!");
37926 const nativeResponseValue = wasm.TS_Stfu_get_channel_id(this_ptr);
37927 return nativeResponseValue;
37929 // void Stfu_set_channel_id(struct LDKStfu *NONNULL_PTR this_ptr, struct LDKChannelId val);
37931 export function Stfu_set_channel_id(this_ptr: bigint, val: bigint): void {
37932 if(!isWasmInitialized) {
37933 throw new Error("initializeWasm() must be awaited first!");
37935 const nativeResponseValue = wasm.TS_Stfu_set_channel_id(this_ptr, val);
37936 // debug statements here
37938 // uint8_t Stfu_get_initiator(const struct LDKStfu *NONNULL_PTR this_ptr);
37940 export function Stfu_get_initiator(this_ptr: bigint): number {
37941 if(!isWasmInitialized) {
37942 throw new Error("initializeWasm() must be awaited first!");
37944 const nativeResponseValue = wasm.TS_Stfu_get_initiator(this_ptr);
37945 return nativeResponseValue;
37947 // void Stfu_set_initiator(struct LDKStfu *NONNULL_PTR this_ptr, uint8_t val);
37949 export function Stfu_set_initiator(this_ptr: bigint, val: number): void {
37950 if(!isWasmInitialized) {
37951 throw new Error("initializeWasm() must be awaited first!");
37953 const nativeResponseValue = wasm.TS_Stfu_set_initiator(this_ptr, val);
37954 // debug statements here
37956 // MUST_USE_RES struct LDKStfu Stfu_new(struct LDKChannelId channel_id_arg, uint8_t initiator_arg);
37958 export function Stfu_new(channel_id_arg: bigint, initiator_arg: number): bigint {
37959 if(!isWasmInitialized) {
37960 throw new Error("initializeWasm() must be awaited first!");
37962 const nativeResponseValue = wasm.TS_Stfu_new(channel_id_arg, initiator_arg);
37963 return nativeResponseValue;
37965 // uint64_t Stfu_clone_ptr(LDKStfu *NONNULL_PTR arg);
37967 export function Stfu_clone_ptr(arg: bigint): bigint {
37968 if(!isWasmInitialized) {
37969 throw new Error("initializeWasm() must be awaited first!");
37971 const nativeResponseValue = wasm.TS_Stfu_clone_ptr(arg);
37972 return nativeResponseValue;
37974 // struct LDKStfu Stfu_clone(const struct LDKStfu *NONNULL_PTR orig);
37976 export function Stfu_clone(orig: bigint): bigint {
37977 if(!isWasmInitialized) {
37978 throw new Error("initializeWasm() must be awaited first!");
37980 const nativeResponseValue = wasm.TS_Stfu_clone(orig);
37981 return nativeResponseValue;
37983 // bool Stfu_eq(const struct LDKStfu *NONNULL_PTR a, const struct LDKStfu *NONNULL_PTR b);
37985 export function Stfu_eq(a: bigint, b: bigint): boolean {
37986 if(!isWasmInitialized) {
37987 throw new Error("initializeWasm() must be awaited first!");
37989 const nativeResponseValue = wasm.TS_Stfu_eq(a, b);
37990 return nativeResponseValue;
37992 // void Splice_free(struct LDKSplice this_obj);
37994 export function Splice_free(this_obj: bigint): void {
37995 if(!isWasmInitialized) {
37996 throw new Error("initializeWasm() must be awaited first!");
37998 const nativeResponseValue = wasm.TS_Splice_free(this_obj);
37999 // debug statements here
38001 // struct LDKChannelId Splice_get_channel_id(const struct LDKSplice *NONNULL_PTR this_ptr);
38003 export function Splice_get_channel_id(this_ptr: bigint): bigint {
38004 if(!isWasmInitialized) {
38005 throw new Error("initializeWasm() must be awaited first!");
38007 const nativeResponseValue = wasm.TS_Splice_get_channel_id(this_ptr);
38008 return nativeResponseValue;
38010 // void Splice_set_channel_id(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKChannelId val);
38012 export function Splice_set_channel_id(this_ptr: bigint, val: bigint): void {
38013 if(!isWasmInitialized) {
38014 throw new Error("initializeWasm() must be awaited first!");
38016 const nativeResponseValue = wasm.TS_Splice_set_channel_id(this_ptr, val);
38017 // debug statements here
38019 // const uint8_t (*Splice_get_chain_hash(const struct LDKSplice *NONNULL_PTR this_ptr))[32];
38021 export function Splice_get_chain_hash(this_ptr: bigint): number {
38022 if(!isWasmInitialized) {
38023 throw new Error("initializeWasm() must be awaited first!");
38025 const nativeResponseValue = wasm.TS_Splice_get_chain_hash(this_ptr);
38026 return nativeResponseValue;
38028 // void Splice_set_chain_hash(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38030 export function Splice_set_chain_hash(this_ptr: bigint, val: number): void {
38031 if(!isWasmInitialized) {
38032 throw new Error("initializeWasm() must be awaited first!");
38034 const nativeResponseValue = wasm.TS_Splice_set_chain_hash(this_ptr, val);
38035 // debug statements here
38037 // int64_t Splice_get_relative_satoshis(const struct LDKSplice *NONNULL_PTR this_ptr);
38039 export function Splice_get_relative_satoshis(this_ptr: bigint): bigint {
38040 if(!isWasmInitialized) {
38041 throw new Error("initializeWasm() must be awaited first!");
38043 const nativeResponseValue = wasm.TS_Splice_get_relative_satoshis(this_ptr);
38044 return nativeResponseValue;
38046 // void Splice_set_relative_satoshis(struct LDKSplice *NONNULL_PTR this_ptr, int64_t val);
38048 export function Splice_set_relative_satoshis(this_ptr: bigint, val: bigint): void {
38049 if(!isWasmInitialized) {
38050 throw new Error("initializeWasm() must be awaited first!");
38052 const nativeResponseValue = wasm.TS_Splice_set_relative_satoshis(this_ptr, val);
38053 // debug statements here
38055 // uint32_t Splice_get_funding_feerate_perkw(const struct LDKSplice *NONNULL_PTR this_ptr);
38057 export function Splice_get_funding_feerate_perkw(this_ptr: bigint): number {
38058 if(!isWasmInitialized) {
38059 throw new Error("initializeWasm() must be awaited first!");
38061 const nativeResponseValue = wasm.TS_Splice_get_funding_feerate_perkw(this_ptr);
38062 return nativeResponseValue;
38064 // void Splice_set_funding_feerate_perkw(struct LDKSplice *NONNULL_PTR this_ptr, uint32_t val);
38066 export function Splice_set_funding_feerate_perkw(this_ptr: bigint, val: number): void {
38067 if(!isWasmInitialized) {
38068 throw new Error("initializeWasm() must be awaited first!");
38070 const nativeResponseValue = wasm.TS_Splice_set_funding_feerate_perkw(this_ptr, val);
38071 // debug statements here
38073 // uint32_t Splice_get_locktime(const struct LDKSplice *NONNULL_PTR this_ptr);
38075 export function Splice_get_locktime(this_ptr: bigint): number {
38076 if(!isWasmInitialized) {
38077 throw new Error("initializeWasm() must be awaited first!");
38079 const nativeResponseValue = wasm.TS_Splice_get_locktime(this_ptr);
38080 return nativeResponseValue;
38082 // void Splice_set_locktime(struct LDKSplice *NONNULL_PTR this_ptr, uint32_t val);
38084 export function Splice_set_locktime(this_ptr: bigint, val: number): void {
38085 if(!isWasmInitialized) {
38086 throw new Error("initializeWasm() must be awaited first!");
38088 const nativeResponseValue = wasm.TS_Splice_set_locktime(this_ptr, val);
38089 // debug statements here
38091 // struct LDKPublicKey Splice_get_funding_pubkey(const struct LDKSplice *NONNULL_PTR this_ptr);
38093 export function Splice_get_funding_pubkey(this_ptr: bigint): number {
38094 if(!isWasmInitialized) {
38095 throw new Error("initializeWasm() must be awaited first!");
38097 const nativeResponseValue = wasm.TS_Splice_get_funding_pubkey(this_ptr);
38098 return nativeResponseValue;
38100 // void Splice_set_funding_pubkey(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKPublicKey val);
38102 export function Splice_set_funding_pubkey(this_ptr: bigint, val: number): void {
38103 if(!isWasmInitialized) {
38104 throw new Error("initializeWasm() must be awaited first!");
38106 const nativeResponseValue = wasm.TS_Splice_set_funding_pubkey(this_ptr, val);
38107 // debug statements here
38109 // MUST_USE_RES struct LDKSplice Splice_new(struct LDKChannelId channel_id_arg, struct LDKThirtyTwoBytes chain_hash_arg, int64_t relative_satoshis_arg, uint32_t funding_feerate_perkw_arg, uint32_t locktime_arg, struct LDKPublicKey funding_pubkey_arg);
38111 export function Splice_new(channel_id_arg: bigint, chain_hash_arg: number, relative_satoshis_arg: bigint, funding_feerate_perkw_arg: number, locktime_arg: number, funding_pubkey_arg: number): bigint {
38112 if(!isWasmInitialized) {
38113 throw new Error("initializeWasm() must be awaited first!");
38115 const nativeResponseValue = wasm.TS_Splice_new(channel_id_arg, chain_hash_arg, relative_satoshis_arg, funding_feerate_perkw_arg, locktime_arg, funding_pubkey_arg);
38116 return nativeResponseValue;
38118 // uint64_t Splice_clone_ptr(LDKSplice *NONNULL_PTR arg);
38120 export function Splice_clone_ptr(arg: bigint): bigint {
38121 if(!isWasmInitialized) {
38122 throw new Error("initializeWasm() must be awaited first!");
38124 const nativeResponseValue = wasm.TS_Splice_clone_ptr(arg);
38125 return nativeResponseValue;
38127 // struct LDKSplice Splice_clone(const struct LDKSplice *NONNULL_PTR orig);
38129 export function Splice_clone(orig: bigint): bigint {
38130 if(!isWasmInitialized) {
38131 throw new Error("initializeWasm() must be awaited first!");
38133 const nativeResponseValue = wasm.TS_Splice_clone(orig);
38134 return nativeResponseValue;
38136 // bool Splice_eq(const struct LDKSplice *NONNULL_PTR a, const struct LDKSplice *NONNULL_PTR b);
38138 export function Splice_eq(a: bigint, b: bigint): boolean {
38139 if(!isWasmInitialized) {
38140 throw new Error("initializeWasm() must be awaited first!");
38142 const nativeResponseValue = wasm.TS_Splice_eq(a, b);
38143 return nativeResponseValue;
38145 // void SpliceAck_free(struct LDKSpliceAck this_obj);
38147 export function SpliceAck_free(this_obj: bigint): void {
38148 if(!isWasmInitialized) {
38149 throw new Error("initializeWasm() must be awaited first!");
38151 const nativeResponseValue = wasm.TS_SpliceAck_free(this_obj);
38152 // debug statements here
38154 // struct LDKChannelId SpliceAck_get_channel_id(const struct LDKSpliceAck *NONNULL_PTR this_ptr);
38156 export function SpliceAck_get_channel_id(this_ptr: bigint): bigint {
38157 if(!isWasmInitialized) {
38158 throw new Error("initializeWasm() must be awaited first!");
38160 const nativeResponseValue = wasm.TS_SpliceAck_get_channel_id(this_ptr);
38161 return nativeResponseValue;
38163 // void SpliceAck_set_channel_id(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKChannelId val);
38165 export function SpliceAck_set_channel_id(this_ptr: bigint, val: bigint): void {
38166 if(!isWasmInitialized) {
38167 throw new Error("initializeWasm() must be awaited first!");
38169 const nativeResponseValue = wasm.TS_SpliceAck_set_channel_id(this_ptr, val);
38170 // debug statements here
38172 // const uint8_t (*SpliceAck_get_chain_hash(const struct LDKSpliceAck *NONNULL_PTR this_ptr))[32];
38174 export function SpliceAck_get_chain_hash(this_ptr: bigint): number {
38175 if(!isWasmInitialized) {
38176 throw new Error("initializeWasm() must be awaited first!");
38178 const nativeResponseValue = wasm.TS_SpliceAck_get_chain_hash(this_ptr);
38179 return nativeResponseValue;
38181 // void SpliceAck_set_chain_hash(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38183 export function SpliceAck_set_chain_hash(this_ptr: bigint, val: number): void {
38184 if(!isWasmInitialized) {
38185 throw new Error("initializeWasm() must be awaited first!");
38187 const nativeResponseValue = wasm.TS_SpliceAck_set_chain_hash(this_ptr, val);
38188 // debug statements here
38190 // int64_t SpliceAck_get_relative_satoshis(const struct LDKSpliceAck *NONNULL_PTR this_ptr);
38192 export function SpliceAck_get_relative_satoshis(this_ptr: bigint): bigint {
38193 if(!isWasmInitialized) {
38194 throw new Error("initializeWasm() must be awaited first!");
38196 const nativeResponseValue = wasm.TS_SpliceAck_get_relative_satoshis(this_ptr);
38197 return nativeResponseValue;
38199 // void SpliceAck_set_relative_satoshis(struct LDKSpliceAck *NONNULL_PTR this_ptr, int64_t val);
38201 export function SpliceAck_set_relative_satoshis(this_ptr: bigint, val: bigint): void {
38202 if(!isWasmInitialized) {
38203 throw new Error("initializeWasm() must be awaited first!");
38205 const nativeResponseValue = wasm.TS_SpliceAck_set_relative_satoshis(this_ptr, val);
38206 // debug statements here
38208 // struct LDKPublicKey SpliceAck_get_funding_pubkey(const struct LDKSpliceAck *NONNULL_PTR this_ptr);
38210 export function SpliceAck_get_funding_pubkey(this_ptr: bigint): number {
38211 if(!isWasmInitialized) {
38212 throw new Error("initializeWasm() must be awaited first!");
38214 const nativeResponseValue = wasm.TS_SpliceAck_get_funding_pubkey(this_ptr);
38215 return nativeResponseValue;
38217 // void SpliceAck_set_funding_pubkey(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKPublicKey val);
38219 export function SpliceAck_set_funding_pubkey(this_ptr: bigint, val: number): void {
38220 if(!isWasmInitialized) {
38221 throw new Error("initializeWasm() must be awaited first!");
38223 const nativeResponseValue = wasm.TS_SpliceAck_set_funding_pubkey(this_ptr, val);
38224 // debug statements here
38226 // MUST_USE_RES struct LDKSpliceAck SpliceAck_new(struct LDKChannelId channel_id_arg, struct LDKThirtyTwoBytes chain_hash_arg, int64_t relative_satoshis_arg, struct LDKPublicKey funding_pubkey_arg);
38228 export function SpliceAck_new(channel_id_arg: bigint, chain_hash_arg: number, relative_satoshis_arg: bigint, funding_pubkey_arg: number): bigint {
38229 if(!isWasmInitialized) {
38230 throw new Error("initializeWasm() must be awaited first!");
38232 const nativeResponseValue = wasm.TS_SpliceAck_new(channel_id_arg, chain_hash_arg, relative_satoshis_arg, funding_pubkey_arg);
38233 return nativeResponseValue;
38235 // uint64_t SpliceAck_clone_ptr(LDKSpliceAck *NONNULL_PTR arg);
38237 export function SpliceAck_clone_ptr(arg: bigint): bigint {
38238 if(!isWasmInitialized) {
38239 throw new Error("initializeWasm() must be awaited first!");
38241 const nativeResponseValue = wasm.TS_SpliceAck_clone_ptr(arg);
38242 return nativeResponseValue;
38244 // struct LDKSpliceAck SpliceAck_clone(const struct LDKSpliceAck *NONNULL_PTR orig);
38246 export function SpliceAck_clone(orig: bigint): bigint {
38247 if(!isWasmInitialized) {
38248 throw new Error("initializeWasm() must be awaited first!");
38250 const nativeResponseValue = wasm.TS_SpliceAck_clone(orig);
38251 return nativeResponseValue;
38253 // bool SpliceAck_eq(const struct LDKSpliceAck *NONNULL_PTR a, const struct LDKSpliceAck *NONNULL_PTR b);
38255 export function SpliceAck_eq(a: bigint, b: bigint): boolean {
38256 if(!isWasmInitialized) {
38257 throw new Error("initializeWasm() must be awaited first!");
38259 const nativeResponseValue = wasm.TS_SpliceAck_eq(a, b);
38260 return nativeResponseValue;
38262 // void SpliceLocked_free(struct LDKSpliceLocked this_obj);
38264 export function SpliceLocked_free(this_obj: bigint): void {
38265 if(!isWasmInitialized) {
38266 throw new Error("initializeWasm() must be awaited first!");
38268 const nativeResponseValue = wasm.TS_SpliceLocked_free(this_obj);
38269 // debug statements here
38271 // struct LDKChannelId SpliceLocked_get_channel_id(const struct LDKSpliceLocked *NONNULL_PTR this_ptr);
38273 export function SpliceLocked_get_channel_id(this_ptr: bigint): bigint {
38274 if(!isWasmInitialized) {
38275 throw new Error("initializeWasm() must be awaited first!");
38277 const nativeResponseValue = wasm.TS_SpliceLocked_get_channel_id(this_ptr);
38278 return nativeResponseValue;
38280 // void SpliceLocked_set_channel_id(struct LDKSpliceLocked *NONNULL_PTR this_ptr, struct LDKChannelId val);
38282 export function SpliceLocked_set_channel_id(this_ptr: bigint, val: bigint): void {
38283 if(!isWasmInitialized) {
38284 throw new Error("initializeWasm() must be awaited first!");
38286 const nativeResponseValue = wasm.TS_SpliceLocked_set_channel_id(this_ptr, val);
38287 // debug statements here
38289 // MUST_USE_RES struct LDKSpliceLocked SpliceLocked_new(struct LDKChannelId channel_id_arg);
38291 export function SpliceLocked_new(channel_id_arg: bigint): bigint {
38292 if(!isWasmInitialized) {
38293 throw new Error("initializeWasm() must be awaited first!");
38295 const nativeResponseValue = wasm.TS_SpliceLocked_new(channel_id_arg);
38296 return nativeResponseValue;
38298 // uint64_t SpliceLocked_clone_ptr(LDKSpliceLocked *NONNULL_PTR arg);
38300 export function SpliceLocked_clone_ptr(arg: bigint): bigint {
38301 if(!isWasmInitialized) {
38302 throw new Error("initializeWasm() must be awaited first!");
38304 const nativeResponseValue = wasm.TS_SpliceLocked_clone_ptr(arg);
38305 return nativeResponseValue;
38307 // struct LDKSpliceLocked SpliceLocked_clone(const struct LDKSpliceLocked *NONNULL_PTR orig);
38309 export function SpliceLocked_clone(orig: bigint): bigint {
38310 if(!isWasmInitialized) {
38311 throw new Error("initializeWasm() must be awaited first!");
38313 const nativeResponseValue = wasm.TS_SpliceLocked_clone(orig);
38314 return nativeResponseValue;
38316 // bool SpliceLocked_eq(const struct LDKSpliceLocked *NONNULL_PTR a, const struct LDKSpliceLocked *NONNULL_PTR b);
38318 export function SpliceLocked_eq(a: bigint, b: bigint): boolean {
38319 if(!isWasmInitialized) {
38320 throw new Error("initializeWasm() must be awaited first!");
38322 const nativeResponseValue = wasm.TS_SpliceLocked_eq(a, b);
38323 return nativeResponseValue;
38325 // void TxAddInput_free(struct LDKTxAddInput this_obj);
38327 export function TxAddInput_free(this_obj: bigint): void {
38328 if(!isWasmInitialized) {
38329 throw new Error("initializeWasm() must be awaited first!");
38331 const nativeResponseValue = wasm.TS_TxAddInput_free(this_obj);
38332 // debug statements here
38334 // struct LDKChannelId TxAddInput_get_channel_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
38336 export function TxAddInput_get_channel_id(this_ptr: bigint): bigint {
38337 if(!isWasmInitialized) {
38338 throw new Error("initializeWasm() must be awaited first!");
38340 const nativeResponseValue = wasm.TS_TxAddInput_get_channel_id(this_ptr);
38341 return nativeResponseValue;
38343 // void TxAddInput_set_channel_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKChannelId val);
38345 export function TxAddInput_set_channel_id(this_ptr: bigint, val: bigint): void {
38346 if(!isWasmInitialized) {
38347 throw new Error("initializeWasm() must be awaited first!");
38349 const nativeResponseValue = wasm.TS_TxAddInput_set_channel_id(this_ptr, val);
38350 // debug statements here
38352 // uint64_t TxAddInput_get_serial_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
38354 export function TxAddInput_get_serial_id(this_ptr: bigint): bigint {
38355 if(!isWasmInitialized) {
38356 throw new Error("initializeWasm() must be awaited first!");
38358 const nativeResponseValue = wasm.TS_TxAddInput_get_serial_id(this_ptr);
38359 return nativeResponseValue;
38361 // void TxAddInput_set_serial_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint64_t val);
38363 export function TxAddInput_set_serial_id(this_ptr: bigint, val: bigint): void {
38364 if(!isWasmInitialized) {
38365 throw new Error("initializeWasm() must be awaited first!");
38367 const nativeResponseValue = wasm.TS_TxAddInput_set_serial_id(this_ptr, val);
38368 // debug statements here
38370 // struct LDKTransactionU16LenLimited TxAddInput_get_prevtx(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
38372 export function TxAddInput_get_prevtx(this_ptr: bigint): bigint {
38373 if(!isWasmInitialized) {
38374 throw new Error("initializeWasm() must be awaited first!");
38376 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx(this_ptr);
38377 return nativeResponseValue;
38379 // void TxAddInput_set_prevtx(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKTransactionU16LenLimited val);
38381 export function TxAddInput_set_prevtx(this_ptr: bigint, val: bigint): void {
38382 if(!isWasmInitialized) {
38383 throw new Error("initializeWasm() must be awaited first!");
38385 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx(this_ptr, val);
38386 // debug statements here
38388 // uint32_t TxAddInput_get_prevtx_out(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
38390 export function TxAddInput_get_prevtx_out(this_ptr: bigint): number {
38391 if(!isWasmInitialized) {
38392 throw new Error("initializeWasm() must be awaited first!");
38394 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx_out(this_ptr);
38395 return nativeResponseValue;
38397 // void TxAddInput_set_prevtx_out(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
38399 export function TxAddInput_set_prevtx_out(this_ptr: bigint, val: number): void {
38400 if(!isWasmInitialized) {
38401 throw new Error("initializeWasm() must be awaited first!");
38403 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx_out(this_ptr, val);
38404 // debug statements here
38406 // uint32_t TxAddInput_get_sequence(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
38408 export function TxAddInput_get_sequence(this_ptr: bigint): number {
38409 if(!isWasmInitialized) {
38410 throw new Error("initializeWasm() must be awaited first!");
38412 const nativeResponseValue = wasm.TS_TxAddInput_get_sequence(this_ptr);
38413 return nativeResponseValue;
38415 // void TxAddInput_set_sequence(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
38417 export function TxAddInput_set_sequence(this_ptr: bigint, val: number): void {
38418 if(!isWasmInitialized) {
38419 throw new Error("initializeWasm() must be awaited first!");
38421 const nativeResponseValue = wasm.TS_TxAddInput_set_sequence(this_ptr, val);
38422 // debug statements here
38424 // MUST_USE_RES struct LDKTxAddInput TxAddInput_new(struct LDKChannelId channel_id_arg, uint64_t serial_id_arg, struct LDKTransactionU16LenLimited prevtx_arg, uint32_t prevtx_out_arg, uint32_t sequence_arg);
38426 export function TxAddInput_new(channel_id_arg: bigint, serial_id_arg: bigint, prevtx_arg: bigint, prevtx_out_arg: number, sequence_arg: number): bigint {
38427 if(!isWasmInitialized) {
38428 throw new Error("initializeWasm() must be awaited first!");
38430 const nativeResponseValue = wasm.TS_TxAddInput_new(channel_id_arg, serial_id_arg, prevtx_arg, prevtx_out_arg, sequence_arg);
38431 return nativeResponseValue;
38433 // uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg);
38435 export function TxAddInput_clone_ptr(arg: bigint): bigint {
38436 if(!isWasmInitialized) {
38437 throw new Error("initializeWasm() must be awaited first!");
38439 const nativeResponseValue = wasm.TS_TxAddInput_clone_ptr(arg);
38440 return nativeResponseValue;
38442 // struct LDKTxAddInput TxAddInput_clone(const struct LDKTxAddInput *NONNULL_PTR orig);
38444 export function TxAddInput_clone(orig: bigint): bigint {
38445 if(!isWasmInitialized) {
38446 throw new Error("initializeWasm() must be awaited first!");
38448 const nativeResponseValue = wasm.TS_TxAddInput_clone(orig);
38449 return nativeResponseValue;
38451 // uint64_t TxAddInput_hash(const struct LDKTxAddInput *NONNULL_PTR o);
38453 export function TxAddInput_hash(o: bigint): bigint {
38454 if(!isWasmInitialized) {
38455 throw new Error("initializeWasm() must be awaited first!");
38457 const nativeResponseValue = wasm.TS_TxAddInput_hash(o);
38458 return nativeResponseValue;
38460 // bool TxAddInput_eq(const struct LDKTxAddInput *NONNULL_PTR a, const struct LDKTxAddInput *NONNULL_PTR b);
38462 export function TxAddInput_eq(a: bigint, b: bigint): boolean {
38463 if(!isWasmInitialized) {
38464 throw new Error("initializeWasm() must be awaited first!");
38466 const nativeResponseValue = wasm.TS_TxAddInput_eq(a, b);
38467 return nativeResponseValue;
38469 // void TxAddOutput_free(struct LDKTxAddOutput this_obj);
38471 export function TxAddOutput_free(this_obj: bigint): void {
38472 if(!isWasmInitialized) {
38473 throw new Error("initializeWasm() must be awaited first!");
38475 const nativeResponseValue = wasm.TS_TxAddOutput_free(this_obj);
38476 // debug statements here
38478 // struct LDKChannelId TxAddOutput_get_channel_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
38480 export function TxAddOutput_get_channel_id(this_ptr: bigint): bigint {
38481 if(!isWasmInitialized) {
38482 throw new Error("initializeWasm() must be awaited first!");
38484 const nativeResponseValue = wasm.TS_TxAddOutput_get_channel_id(this_ptr);
38485 return nativeResponseValue;
38487 // void TxAddOutput_set_channel_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKChannelId val);
38489 export function TxAddOutput_set_channel_id(this_ptr: bigint, val: bigint): void {
38490 if(!isWasmInitialized) {
38491 throw new Error("initializeWasm() must be awaited first!");
38493 const nativeResponseValue = wasm.TS_TxAddOutput_set_channel_id(this_ptr, val);
38494 // debug statements here
38496 // uint64_t TxAddOutput_get_serial_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
38498 export function TxAddOutput_get_serial_id(this_ptr: bigint): bigint {
38499 if(!isWasmInitialized) {
38500 throw new Error("initializeWasm() must be awaited first!");
38502 const nativeResponseValue = wasm.TS_TxAddOutput_get_serial_id(this_ptr);
38503 return nativeResponseValue;
38505 // void TxAddOutput_set_serial_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
38507 export function TxAddOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
38508 if(!isWasmInitialized) {
38509 throw new Error("initializeWasm() must be awaited first!");
38511 const nativeResponseValue = wasm.TS_TxAddOutput_set_serial_id(this_ptr, val);
38512 // debug statements here
38514 // uint64_t TxAddOutput_get_sats(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
38516 export function TxAddOutput_get_sats(this_ptr: bigint): bigint {
38517 if(!isWasmInitialized) {
38518 throw new Error("initializeWasm() must be awaited first!");
38520 const nativeResponseValue = wasm.TS_TxAddOutput_get_sats(this_ptr);
38521 return nativeResponseValue;
38523 // void TxAddOutput_set_sats(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
38525 export function TxAddOutput_set_sats(this_ptr: bigint, val: bigint): void {
38526 if(!isWasmInitialized) {
38527 throw new Error("initializeWasm() must be awaited first!");
38529 const nativeResponseValue = wasm.TS_TxAddOutput_set_sats(this_ptr, val);
38530 // debug statements here
38532 // struct LDKCVec_u8Z TxAddOutput_get_script(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
38534 export function TxAddOutput_get_script(this_ptr: bigint): number {
38535 if(!isWasmInitialized) {
38536 throw new Error("initializeWasm() must be awaited first!");
38538 const nativeResponseValue = wasm.TS_TxAddOutput_get_script(this_ptr);
38539 return nativeResponseValue;
38541 // void TxAddOutput_set_script(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
38543 export function TxAddOutput_set_script(this_ptr: bigint, val: number): void {
38544 if(!isWasmInitialized) {
38545 throw new Error("initializeWasm() must be awaited first!");
38547 const nativeResponseValue = wasm.TS_TxAddOutput_set_script(this_ptr, val);
38548 // debug statements here
38550 // MUST_USE_RES struct LDKTxAddOutput TxAddOutput_new(struct LDKChannelId channel_id_arg, uint64_t serial_id_arg, uint64_t sats_arg, struct LDKCVec_u8Z script_arg);
38552 export function TxAddOutput_new(channel_id_arg: bigint, serial_id_arg: bigint, sats_arg: bigint, script_arg: number): bigint {
38553 if(!isWasmInitialized) {
38554 throw new Error("initializeWasm() must be awaited first!");
38556 const nativeResponseValue = wasm.TS_TxAddOutput_new(channel_id_arg, serial_id_arg, sats_arg, script_arg);
38557 return nativeResponseValue;
38559 // uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg);
38561 export function TxAddOutput_clone_ptr(arg: bigint): bigint {
38562 if(!isWasmInitialized) {
38563 throw new Error("initializeWasm() must be awaited first!");
38565 const nativeResponseValue = wasm.TS_TxAddOutput_clone_ptr(arg);
38566 return nativeResponseValue;
38568 // struct LDKTxAddOutput TxAddOutput_clone(const struct LDKTxAddOutput *NONNULL_PTR orig);
38570 export function TxAddOutput_clone(orig: bigint): bigint {
38571 if(!isWasmInitialized) {
38572 throw new Error("initializeWasm() must be awaited first!");
38574 const nativeResponseValue = wasm.TS_TxAddOutput_clone(orig);
38575 return nativeResponseValue;
38577 // uint64_t TxAddOutput_hash(const struct LDKTxAddOutput *NONNULL_PTR o);
38579 export function TxAddOutput_hash(o: bigint): bigint {
38580 if(!isWasmInitialized) {
38581 throw new Error("initializeWasm() must be awaited first!");
38583 const nativeResponseValue = wasm.TS_TxAddOutput_hash(o);
38584 return nativeResponseValue;
38586 // bool TxAddOutput_eq(const struct LDKTxAddOutput *NONNULL_PTR a, const struct LDKTxAddOutput *NONNULL_PTR b);
38588 export function TxAddOutput_eq(a: bigint, b: bigint): boolean {
38589 if(!isWasmInitialized) {
38590 throw new Error("initializeWasm() must be awaited first!");
38592 const nativeResponseValue = wasm.TS_TxAddOutput_eq(a, b);
38593 return nativeResponseValue;
38595 // void TxRemoveInput_free(struct LDKTxRemoveInput this_obj);
38597 export function TxRemoveInput_free(this_obj: bigint): void {
38598 if(!isWasmInitialized) {
38599 throw new Error("initializeWasm() must be awaited first!");
38601 const nativeResponseValue = wasm.TS_TxRemoveInput_free(this_obj);
38602 // debug statements here
38604 // struct LDKChannelId TxRemoveInput_get_channel_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
38606 export function TxRemoveInput_get_channel_id(this_ptr: bigint): bigint {
38607 if(!isWasmInitialized) {
38608 throw new Error("initializeWasm() must be awaited first!");
38610 const nativeResponseValue = wasm.TS_TxRemoveInput_get_channel_id(this_ptr);
38611 return nativeResponseValue;
38613 // void TxRemoveInput_set_channel_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, struct LDKChannelId val);
38615 export function TxRemoveInput_set_channel_id(this_ptr: bigint, val: bigint): void {
38616 if(!isWasmInitialized) {
38617 throw new Error("initializeWasm() must be awaited first!");
38619 const nativeResponseValue = wasm.TS_TxRemoveInput_set_channel_id(this_ptr, val);
38620 // debug statements here
38622 // uint64_t TxRemoveInput_get_serial_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
38624 export function TxRemoveInput_get_serial_id(this_ptr: bigint): bigint {
38625 if(!isWasmInitialized) {
38626 throw new Error("initializeWasm() must be awaited first!");
38628 const nativeResponseValue = wasm.TS_TxRemoveInput_get_serial_id(this_ptr);
38629 return nativeResponseValue;
38631 // void TxRemoveInput_set_serial_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, uint64_t val);
38633 export function TxRemoveInput_set_serial_id(this_ptr: bigint, val: bigint): void {
38634 if(!isWasmInitialized) {
38635 throw new Error("initializeWasm() must be awaited first!");
38637 const nativeResponseValue = wasm.TS_TxRemoveInput_set_serial_id(this_ptr, val);
38638 // debug statements here
38640 // MUST_USE_RES struct LDKTxRemoveInput TxRemoveInput_new(struct LDKChannelId channel_id_arg, uint64_t serial_id_arg);
38642 export function TxRemoveInput_new(channel_id_arg: bigint, serial_id_arg: bigint): bigint {
38643 if(!isWasmInitialized) {
38644 throw new Error("initializeWasm() must be awaited first!");
38646 const nativeResponseValue = wasm.TS_TxRemoveInput_new(channel_id_arg, serial_id_arg);
38647 return nativeResponseValue;
38649 // uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg);
38651 export function TxRemoveInput_clone_ptr(arg: bigint): bigint {
38652 if(!isWasmInitialized) {
38653 throw new Error("initializeWasm() must be awaited first!");
38655 const nativeResponseValue = wasm.TS_TxRemoveInput_clone_ptr(arg);
38656 return nativeResponseValue;
38658 // struct LDKTxRemoveInput TxRemoveInput_clone(const struct LDKTxRemoveInput *NONNULL_PTR orig);
38660 export function TxRemoveInput_clone(orig: bigint): bigint {
38661 if(!isWasmInitialized) {
38662 throw new Error("initializeWasm() must be awaited first!");
38664 const nativeResponseValue = wasm.TS_TxRemoveInput_clone(orig);
38665 return nativeResponseValue;
38667 // uint64_t TxRemoveInput_hash(const struct LDKTxRemoveInput *NONNULL_PTR o);
38669 export function TxRemoveInput_hash(o: bigint): bigint {
38670 if(!isWasmInitialized) {
38671 throw new Error("initializeWasm() must be awaited first!");
38673 const nativeResponseValue = wasm.TS_TxRemoveInput_hash(o);
38674 return nativeResponseValue;
38676 // bool TxRemoveInput_eq(const struct LDKTxRemoveInput *NONNULL_PTR a, const struct LDKTxRemoveInput *NONNULL_PTR b);
38678 export function TxRemoveInput_eq(a: bigint, b: bigint): boolean {
38679 if(!isWasmInitialized) {
38680 throw new Error("initializeWasm() must be awaited first!");
38682 const nativeResponseValue = wasm.TS_TxRemoveInput_eq(a, b);
38683 return nativeResponseValue;
38685 // void TxRemoveOutput_free(struct LDKTxRemoveOutput this_obj);
38687 export function TxRemoveOutput_free(this_obj: bigint): void {
38688 if(!isWasmInitialized) {
38689 throw new Error("initializeWasm() must be awaited first!");
38691 const nativeResponseValue = wasm.TS_TxRemoveOutput_free(this_obj);
38692 // debug statements here
38694 // struct LDKChannelId TxRemoveOutput_get_channel_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
38696 export function TxRemoveOutput_get_channel_id(this_ptr: bigint): bigint {
38697 if(!isWasmInitialized) {
38698 throw new Error("initializeWasm() must be awaited first!");
38700 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_channel_id(this_ptr);
38701 return nativeResponseValue;
38703 // void TxRemoveOutput_set_channel_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, struct LDKChannelId val);
38705 export function TxRemoveOutput_set_channel_id(this_ptr: bigint, val: bigint): void {
38706 if(!isWasmInitialized) {
38707 throw new Error("initializeWasm() must be awaited first!");
38709 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_channel_id(this_ptr, val);
38710 // debug statements here
38712 // uint64_t TxRemoveOutput_get_serial_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
38714 export function TxRemoveOutput_get_serial_id(this_ptr: bigint): bigint {
38715 if(!isWasmInitialized) {
38716 throw new Error("initializeWasm() must be awaited first!");
38718 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_serial_id(this_ptr);
38719 return nativeResponseValue;
38721 // void TxRemoveOutput_set_serial_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, uint64_t val);
38723 export function TxRemoveOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
38724 if(!isWasmInitialized) {
38725 throw new Error("initializeWasm() must be awaited first!");
38727 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_serial_id(this_ptr, val);
38728 // debug statements here
38730 // MUST_USE_RES struct LDKTxRemoveOutput TxRemoveOutput_new(struct LDKChannelId channel_id_arg, uint64_t serial_id_arg);
38732 export function TxRemoveOutput_new(channel_id_arg: bigint, serial_id_arg: bigint): bigint {
38733 if(!isWasmInitialized) {
38734 throw new Error("initializeWasm() must be awaited first!");
38736 const nativeResponseValue = wasm.TS_TxRemoveOutput_new(channel_id_arg, serial_id_arg);
38737 return nativeResponseValue;
38739 // uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg);
38741 export function TxRemoveOutput_clone_ptr(arg: bigint): bigint {
38742 if(!isWasmInitialized) {
38743 throw new Error("initializeWasm() must be awaited first!");
38745 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone_ptr(arg);
38746 return nativeResponseValue;
38748 // struct LDKTxRemoveOutput TxRemoveOutput_clone(const struct LDKTxRemoveOutput *NONNULL_PTR orig);
38750 export function TxRemoveOutput_clone(orig: bigint): bigint {
38751 if(!isWasmInitialized) {
38752 throw new Error("initializeWasm() must be awaited first!");
38754 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone(orig);
38755 return nativeResponseValue;
38757 // uint64_t TxRemoveOutput_hash(const struct LDKTxRemoveOutput *NONNULL_PTR o);
38759 export function TxRemoveOutput_hash(o: bigint): bigint {
38760 if(!isWasmInitialized) {
38761 throw new Error("initializeWasm() must be awaited first!");
38763 const nativeResponseValue = wasm.TS_TxRemoveOutput_hash(o);
38764 return nativeResponseValue;
38766 // bool TxRemoveOutput_eq(const struct LDKTxRemoveOutput *NONNULL_PTR a, const struct LDKTxRemoveOutput *NONNULL_PTR b);
38768 export function TxRemoveOutput_eq(a: bigint, b: bigint): boolean {
38769 if(!isWasmInitialized) {
38770 throw new Error("initializeWasm() must be awaited first!");
38772 const nativeResponseValue = wasm.TS_TxRemoveOutput_eq(a, b);
38773 return nativeResponseValue;
38775 // void TxComplete_free(struct LDKTxComplete this_obj);
38777 export function TxComplete_free(this_obj: bigint): void {
38778 if(!isWasmInitialized) {
38779 throw new Error("initializeWasm() must be awaited first!");
38781 const nativeResponseValue = wasm.TS_TxComplete_free(this_obj);
38782 // debug statements here
38784 // struct LDKChannelId TxComplete_get_channel_id(const struct LDKTxComplete *NONNULL_PTR this_ptr);
38786 export function TxComplete_get_channel_id(this_ptr: bigint): bigint {
38787 if(!isWasmInitialized) {
38788 throw new Error("initializeWasm() must be awaited first!");
38790 const nativeResponseValue = wasm.TS_TxComplete_get_channel_id(this_ptr);
38791 return nativeResponseValue;
38793 // void TxComplete_set_channel_id(struct LDKTxComplete *NONNULL_PTR this_ptr, struct LDKChannelId val);
38795 export function TxComplete_set_channel_id(this_ptr: bigint, val: bigint): void {
38796 if(!isWasmInitialized) {
38797 throw new Error("initializeWasm() must be awaited first!");
38799 const nativeResponseValue = wasm.TS_TxComplete_set_channel_id(this_ptr, val);
38800 // debug statements here
38802 // MUST_USE_RES struct LDKTxComplete TxComplete_new(struct LDKChannelId channel_id_arg);
38804 export function TxComplete_new(channel_id_arg: bigint): bigint {
38805 if(!isWasmInitialized) {
38806 throw new Error("initializeWasm() must be awaited first!");
38808 const nativeResponseValue = wasm.TS_TxComplete_new(channel_id_arg);
38809 return nativeResponseValue;
38811 // uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg);
38813 export function TxComplete_clone_ptr(arg: bigint): bigint {
38814 if(!isWasmInitialized) {
38815 throw new Error("initializeWasm() must be awaited first!");
38817 const nativeResponseValue = wasm.TS_TxComplete_clone_ptr(arg);
38818 return nativeResponseValue;
38820 // struct LDKTxComplete TxComplete_clone(const struct LDKTxComplete *NONNULL_PTR orig);
38822 export function TxComplete_clone(orig: bigint): bigint {
38823 if(!isWasmInitialized) {
38824 throw new Error("initializeWasm() must be awaited first!");
38826 const nativeResponseValue = wasm.TS_TxComplete_clone(orig);
38827 return nativeResponseValue;
38829 // uint64_t TxComplete_hash(const struct LDKTxComplete *NONNULL_PTR o);
38831 export function TxComplete_hash(o: bigint): bigint {
38832 if(!isWasmInitialized) {
38833 throw new Error("initializeWasm() must be awaited first!");
38835 const nativeResponseValue = wasm.TS_TxComplete_hash(o);
38836 return nativeResponseValue;
38838 // bool TxComplete_eq(const struct LDKTxComplete *NONNULL_PTR a, const struct LDKTxComplete *NONNULL_PTR b);
38840 export function TxComplete_eq(a: bigint, b: bigint): boolean {
38841 if(!isWasmInitialized) {
38842 throw new Error("initializeWasm() must be awaited first!");
38844 const nativeResponseValue = wasm.TS_TxComplete_eq(a, b);
38845 return nativeResponseValue;
38847 // void TxSignatures_free(struct LDKTxSignatures this_obj);
38849 export function TxSignatures_free(this_obj: bigint): void {
38850 if(!isWasmInitialized) {
38851 throw new Error("initializeWasm() must be awaited first!");
38853 const nativeResponseValue = wasm.TS_TxSignatures_free(this_obj);
38854 // debug statements here
38856 // struct LDKChannelId TxSignatures_get_channel_id(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
38858 export function TxSignatures_get_channel_id(this_ptr: bigint): bigint {
38859 if(!isWasmInitialized) {
38860 throw new Error("initializeWasm() must be awaited first!");
38862 const nativeResponseValue = wasm.TS_TxSignatures_get_channel_id(this_ptr);
38863 return nativeResponseValue;
38865 // void TxSignatures_set_channel_id(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKChannelId val);
38867 export function TxSignatures_set_channel_id(this_ptr: bigint, val: bigint): void {
38868 if(!isWasmInitialized) {
38869 throw new Error("initializeWasm() must be awaited first!");
38871 const nativeResponseValue = wasm.TS_TxSignatures_set_channel_id(this_ptr, val);
38872 // debug statements here
38874 // const uint8_t (*TxSignatures_get_tx_hash(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
38876 export function TxSignatures_get_tx_hash(this_ptr: bigint): number {
38877 if(!isWasmInitialized) {
38878 throw new Error("initializeWasm() must be awaited first!");
38880 const nativeResponseValue = wasm.TS_TxSignatures_get_tx_hash(this_ptr);
38881 return nativeResponseValue;
38883 // void TxSignatures_set_tx_hash(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38885 export function TxSignatures_set_tx_hash(this_ptr: bigint, val: number): void {
38886 if(!isWasmInitialized) {
38887 throw new Error("initializeWasm() must be awaited first!");
38889 const nativeResponseValue = wasm.TS_TxSignatures_set_tx_hash(this_ptr, val);
38890 // debug statements here
38892 // struct LDKCVec_WitnessZ TxSignatures_get_witnesses(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
38894 export function TxSignatures_get_witnesses(this_ptr: bigint): number {
38895 if(!isWasmInitialized) {
38896 throw new Error("initializeWasm() must be awaited first!");
38898 const nativeResponseValue = wasm.TS_TxSignatures_get_witnesses(this_ptr);
38899 return nativeResponseValue;
38901 // void TxSignatures_set_witnesses(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCVec_WitnessZ val);
38903 export function TxSignatures_set_witnesses(this_ptr: bigint, val: number): void {
38904 if(!isWasmInitialized) {
38905 throw new Error("initializeWasm() must be awaited first!");
38907 const nativeResponseValue = wasm.TS_TxSignatures_set_witnesses(this_ptr, val);
38908 // debug statements here
38910 // struct LDKCOption_ECDSASignatureZ TxSignatures_get_funding_outpoint_sig(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
38912 export function TxSignatures_get_funding_outpoint_sig(this_ptr: bigint): bigint {
38913 if(!isWasmInitialized) {
38914 throw new Error("initializeWasm() must be awaited first!");
38916 const nativeResponseValue = wasm.TS_TxSignatures_get_funding_outpoint_sig(this_ptr);
38917 return nativeResponseValue;
38919 // void TxSignatures_set_funding_outpoint_sig(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCOption_ECDSASignatureZ val);
38921 export function TxSignatures_set_funding_outpoint_sig(this_ptr: bigint, val: bigint): void {
38922 if(!isWasmInitialized) {
38923 throw new Error("initializeWasm() must be awaited first!");
38925 const nativeResponseValue = wasm.TS_TxSignatures_set_funding_outpoint_sig(this_ptr, val);
38926 // debug statements here
38928 // MUST_USE_RES struct LDKTxSignatures TxSignatures_new(struct LDKChannelId channel_id_arg, struct LDKThirtyTwoBytes tx_hash_arg, struct LDKCVec_WitnessZ witnesses_arg, struct LDKCOption_ECDSASignatureZ funding_outpoint_sig_arg);
38930 export function TxSignatures_new(channel_id_arg: bigint, tx_hash_arg: number, witnesses_arg: number, funding_outpoint_sig_arg: bigint): bigint {
38931 if(!isWasmInitialized) {
38932 throw new Error("initializeWasm() must be awaited first!");
38934 const nativeResponseValue = wasm.TS_TxSignatures_new(channel_id_arg, tx_hash_arg, witnesses_arg, funding_outpoint_sig_arg);
38935 return nativeResponseValue;
38937 // uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg);
38939 export function TxSignatures_clone_ptr(arg: bigint): bigint {
38940 if(!isWasmInitialized) {
38941 throw new Error("initializeWasm() must be awaited first!");
38943 const nativeResponseValue = wasm.TS_TxSignatures_clone_ptr(arg);
38944 return nativeResponseValue;
38946 // struct LDKTxSignatures TxSignatures_clone(const struct LDKTxSignatures *NONNULL_PTR orig);
38948 export function TxSignatures_clone(orig: bigint): bigint {
38949 if(!isWasmInitialized) {
38950 throw new Error("initializeWasm() must be awaited first!");
38952 const nativeResponseValue = wasm.TS_TxSignatures_clone(orig);
38953 return nativeResponseValue;
38955 // uint64_t TxSignatures_hash(const struct LDKTxSignatures *NONNULL_PTR o);
38957 export function TxSignatures_hash(o: bigint): bigint {
38958 if(!isWasmInitialized) {
38959 throw new Error("initializeWasm() must be awaited first!");
38961 const nativeResponseValue = wasm.TS_TxSignatures_hash(o);
38962 return nativeResponseValue;
38964 // bool TxSignatures_eq(const struct LDKTxSignatures *NONNULL_PTR a, const struct LDKTxSignatures *NONNULL_PTR b);
38966 export function TxSignatures_eq(a: bigint, b: bigint): boolean {
38967 if(!isWasmInitialized) {
38968 throw new Error("initializeWasm() must be awaited first!");
38970 const nativeResponseValue = wasm.TS_TxSignatures_eq(a, b);
38971 return nativeResponseValue;
38973 // void TxInitRbf_free(struct LDKTxInitRbf this_obj);
38975 export function TxInitRbf_free(this_obj: bigint): void {
38976 if(!isWasmInitialized) {
38977 throw new Error("initializeWasm() must be awaited first!");
38979 const nativeResponseValue = wasm.TS_TxInitRbf_free(this_obj);
38980 // debug statements here
38982 // struct LDKChannelId TxInitRbf_get_channel_id(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
38984 export function TxInitRbf_get_channel_id(this_ptr: bigint): bigint {
38985 if(!isWasmInitialized) {
38986 throw new Error("initializeWasm() must be awaited first!");
38988 const nativeResponseValue = wasm.TS_TxInitRbf_get_channel_id(this_ptr);
38989 return nativeResponseValue;
38991 // void TxInitRbf_set_channel_id(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKChannelId val);
38993 export function TxInitRbf_set_channel_id(this_ptr: bigint, val: bigint): void {
38994 if(!isWasmInitialized) {
38995 throw new Error("initializeWasm() must be awaited first!");
38997 const nativeResponseValue = wasm.TS_TxInitRbf_set_channel_id(this_ptr, val);
38998 // debug statements here
39000 // uint32_t TxInitRbf_get_locktime(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
39002 export function TxInitRbf_get_locktime(this_ptr: bigint): number {
39003 if(!isWasmInitialized) {
39004 throw new Error("initializeWasm() must be awaited first!");
39006 const nativeResponseValue = wasm.TS_TxInitRbf_get_locktime(this_ptr);
39007 return nativeResponseValue;
39009 // void TxInitRbf_set_locktime(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
39011 export function TxInitRbf_set_locktime(this_ptr: bigint, val: number): void {
39012 if(!isWasmInitialized) {
39013 throw new Error("initializeWasm() must be awaited first!");
39015 const nativeResponseValue = wasm.TS_TxInitRbf_set_locktime(this_ptr, val);
39016 // debug statements here
39018 // uint32_t TxInitRbf_get_feerate_sat_per_1000_weight(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
39020 export function TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: bigint): number {
39021 if(!isWasmInitialized) {
39022 throw new Error("initializeWasm() must be awaited first!");
39024 const nativeResponseValue = wasm.TS_TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr);
39025 return nativeResponseValue;
39027 // void TxInitRbf_set_feerate_sat_per_1000_weight(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
39029 export function TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
39030 if(!isWasmInitialized) {
39031 throw new Error("initializeWasm() must be awaited first!");
39033 const nativeResponseValue = wasm.TS_TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr, val);
39034 // debug statements here
39036 // struct LDKCOption_i64Z TxInitRbf_get_funding_output_contribution(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
39038 export function TxInitRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
39039 if(!isWasmInitialized) {
39040 throw new Error("initializeWasm() must be awaited first!");
39042 const nativeResponseValue = wasm.TS_TxInitRbf_get_funding_output_contribution(this_ptr);
39043 return nativeResponseValue;
39045 // void TxInitRbf_set_funding_output_contribution(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
39047 export function TxInitRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
39048 if(!isWasmInitialized) {
39049 throw new Error("initializeWasm() must be awaited first!");
39051 const nativeResponseValue = wasm.TS_TxInitRbf_set_funding_output_contribution(this_ptr, val);
39052 // debug statements here
39054 // MUST_USE_RES struct LDKTxInitRbf TxInitRbf_new(struct LDKChannelId channel_id_arg, uint32_t locktime_arg, uint32_t feerate_sat_per_1000_weight_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
39056 export function TxInitRbf_new(channel_id_arg: bigint, locktime_arg: number, feerate_sat_per_1000_weight_arg: number, funding_output_contribution_arg: bigint): bigint {
39057 if(!isWasmInitialized) {
39058 throw new Error("initializeWasm() must be awaited first!");
39060 const nativeResponseValue = wasm.TS_TxInitRbf_new(channel_id_arg, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg);
39061 return nativeResponseValue;
39063 // uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg);
39065 export function TxInitRbf_clone_ptr(arg: bigint): bigint {
39066 if(!isWasmInitialized) {
39067 throw new Error("initializeWasm() must be awaited first!");
39069 const nativeResponseValue = wasm.TS_TxInitRbf_clone_ptr(arg);
39070 return nativeResponseValue;
39072 // struct LDKTxInitRbf TxInitRbf_clone(const struct LDKTxInitRbf *NONNULL_PTR orig);
39074 export function TxInitRbf_clone(orig: bigint): bigint {
39075 if(!isWasmInitialized) {
39076 throw new Error("initializeWasm() must be awaited first!");
39078 const nativeResponseValue = wasm.TS_TxInitRbf_clone(orig);
39079 return nativeResponseValue;
39081 // uint64_t TxInitRbf_hash(const struct LDKTxInitRbf *NONNULL_PTR o);
39083 export function TxInitRbf_hash(o: bigint): bigint {
39084 if(!isWasmInitialized) {
39085 throw new Error("initializeWasm() must be awaited first!");
39087 const nativeResponseValue = wasm.TS_TxInitRbf_hash(o);
39088 return nativeResponseValue;
39090 // bool TxInitRbf_eq(const struct LDKTxInitRbf *NONNULL_PTR a, const struct LDKTxInitRbf *NONNULL_PTR b);
39092 export function TxInitRbf_eq(a: bigint, b: bigint): boolean {
39093 if(!isWasmInitialized) {
39094 throw new Error("initializeWasm() must be awaited first!");
39096 const nativeResponseValue = wasm.TS_TxInitRbf_eq(a, b);
39097 return nativeResponseValue;
39099 // void TxAckRbf_free(struct LDKTxAckRbf this_obj);
39101 export function TxAckRbf_free(this_obj: bigint): void {
39102 if(!isWasmInitialized) {
39103 throw new Error("initializeWasm() must be awaited first!");
39105 const nativeResponseValue = wasm.TS_TxAckRbf_free(this_obj);
39106 // debug statements here
39108 // struct LDKChannelId TxAckRbf_get_channel_id(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
39110 export function TxAckRbf_get_channel_id(this_ptr: bigint): bigint {
39111 if(!isWasmInitialized) {
39112 throw new Error("initializeWasm() must be awaited first!");
39114 const nativeResponseValue = wasm.TS_TxAckRbf_get_channel_id(this_ptr);
39115 return nativeResponseValue;
39117 // void TxAckRbf_set_channel_id(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKChannelId val);
39119 export function TxAckRbf_set_channel_id(this_ptr: bigint, val: bigint): void {
39120 if(!isWasmInitialized) {
39121 throw new Error("initializeWasm() must be awaited first!");
39123 const nativeResponseValue = wasm.TS_TxAckRbf_set_channel_id(this_ptr, val);
39124 // debug statements here
39126 // struct LDKCOption_i64Z TxAckRbf_get_funding_output_contribution(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
39128 export function TxAckRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
39129 if(!isWasmInitialized) {
39130 throw new Error("initializeWasm() must be awaited first!");
39132 const nativeResponseValue = wasm.TS_TxAckRbf_get_funding_output_contribution(this_ptr);
39133 return nativeResponseValue;
39135 // void TxAckRbf_set_funding_output_contribution(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
39137 export function TxAckRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
39138 if(!isWasmInitialized) {
39139 throw new Error("initializeWasm() must be awaited first!");
39141 const nativeResponseValue = wasm.TS_TxAckRbf_set_funding_output_contribution(this_ptr, val);
39142 // debug statements here
39144 // MUST_USE_RES struct LDKTxAckRbf TxAckRbf_new(struct LDKChannelId channel_id_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
39146 export function TxAckRbf_new(channel_id_arg: bigint, funding_output_contribution_arg: bigint): bigint {
39147 if(!isWasmInitialized) {
39148 throw new Error("initializeWasm() must be awaited first!");
39150 const nativeResponseValue = wasm.TS_TxAckRbf_new(channel_id_arg, funding_output_contribution_arg);
39151 return nativeResponseValue;
39153 // uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg);
39155 export function TxAckRbf_clone_ptr(arg: bigint): bigint {
39156 if(!isWasmInitialized) {
39157 throw new Error("initializeWasm() must be awaited first!");
39159 const nativeResponseValue = wasm.TS_TxAckRbf_clone_ptr(arg);
39160 return nativeResponseValue;
39162 // struct LDKTxAckRbf TxAckRbf_clone(const struct LDKTxAckRbf *NONNULL_PTR orig);
39164 export function TxAckRbf_clone(orig: bigint): bigint {
39165 if(!isWasmInitialized) {
39166 throw new Error("initializeWasm() must be awaited first!");
39168 const nativeResponseValue = wasm.TS_TxAckRbf_clone(orig);
39169 return nativeResponseValue;
39171 // uint64_t TxAckRbf_hash(const struct LDKTxAckRbf *NONNULL_PTR o);
39173 export function TxAckRbf_hash(o: bigint): bigint {
39174 if(!isWasmInitialized) {
39175 throw new Error("initializeWasm() must be awaited first!");
39177 const nativeResponseValue = wasm.TS_TxAckRbf_hash(o);
39178 return nativeResponseValue;
39180 // bool TxAckRbf_eq(const struct LDKTxAckRbf *NONNULL_PTR a, const struct LDKTxAckRbf *NONNULL_PTR b);
39182 export function TxAckRbf_eq(a: bigint, b: bigint): boolean {
39183 if(!isWasmInitialized) {
39184 throw new Error("initializeWasm() must be awaited first!");
39186 const nativeResponseValue = wasm.TS_TxAckRbf_eq(a, b);
39187 return nativeResponseValue;
39189 // void TxAbort_free(struct LDKTxAbort this_obj);
39191 export function TxAbort_free(this_obj: bigint): void {
39192 if(!isWasmInitialized) {
39193 throw new Error("initializeWasm() must be awaited first!");
39195 const nativeResponseValue = wasm.TS_TxAbort_free(this_obj);
39196 // debug statements here
39198 // struct LDKChannelId TxAbort_get_channel_id(const struct LDKTxAbort *NONNULL_PTR this_ptr);
39200 export function TxAbort_get_channel_id(this_ptr: bigint): bigint {
39201 if(!isWasmInitialized) {
39202 throw new Error("initializeWasm() must be awaited first!");
39204 const nativeResponseValue = wasm.TS_TxAbort_get_channel_id(this_ptr);
39205 return nativeResponseValue;
39207 // void TxAbort_set_channel_id(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKChannelId val);
39209 export function TxAbort_set_channel_id(this_ptr: bigint, val: bigint): void {
39210 if(!isWasmInitialized) {
39211 throw new Error("initializeWasm() must be awaited first!");
39213 const nativeResponseValue = wasm.TS_TxAbort_set_channel_id(this_ptr, val);
39214 // debug statements here
39216 // struct LDKCVec_u8Z TxAbort_get_data(const struct LDKTxAbort *NONNULL_PTR this_ptr);
39218 export function TxAbort_get_data(this_ptr: bigint): number {
39219 if(!isWasmInitialized) {
39220 throw new Error("initializeWasm() must be awaited first!");
39222 const nativeResponseValue = wasm.TS_TxAbort_get_data(this_ptr);
39223 return nativeResponseValue;
39225 // void TxAbort_set_data(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
39227 export function TxAbort_set_data(this_ptr: bigint, val: number): void {
39228 if(!isWasmInitialized) {
39229 throw new Error("initializeWasm() must be awaited first!");
39231 const nativeResponseValue = wasm.TS_TxAbort_set_data(this_ptr, val);
39232 // debug statements here
39234 // MUST_USE_RES struct LDKTxAbort TxAbort_new(struct LDKChannelId channel_id_arg, struct LDKCVec_u8Z data_arg);
39236 export function TxAbort_new(channel_id_arg: bigint, data_arg: number): bigint {
39237 if(!isWasmInitialized) {
39238 throw new Error("initializeWasm() must be awaited first!");
39240 const nativeResponseValue = wasm.TS_TxAbort_new(channel_id_arg, data_arg);
39241 return nativeResponseValue;
39243 // uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg);
39245 export function TxAbort_clone_ptr(arg: bigint): bigint {
39246 if(!isWasmInitialized) {
39247 throw new Error("initializeWasm() must be awaited first!");
39249 const nativeResponseValue = wasm.TS_TxAbort_clone_ptr(arg);
39250 return nativeResponseValue;
39252 // struct LDKTxAbort TxAbort_clone(const struct LDKTxAbort *NONNULL_PTR orig);
39254 export function TxAbort_clone(orig: bigint): bigint {
39255 if(!isWasmInitialized) {
39256 throw new Error("initializeWasm() must be awaited first!");
39258 const nativeResponseValue = wasm.TS_TxAbort_clone(orig);
39259 return nativeResponseValue;
39261 // uint64_t TxAbort_hash(const struct LDKTxAbort *NONNULL_PTR o);
39263 export function TxAbort_hash(o: bigint): bigint {
39264 if(!isWasmInitialized) {
39265 throw new Error("initializeWasm() must be awaited first!");
39267 const nativeResponseValue = wasm.TS_TxAbort_hash(o);
39268 return nativeResponseValue;
39270 // bool TxAbort_eq(const struct LDKTxAbort *NONNULL_PTR a, const struct LDKTxAbort *NONNULL_PTR b);
39272 export function TxAbort_eq(a: bigint, b: bigint): boolean {
39273 if(!isWasmInitialized) {
39274 throw new Error("initializeWasm() must be awaited first!");
39276 const nativeResponseValue = wasm.TS_TxAbort_eq(a, b);
39277 return nativeResponseValue;
39279 // void Shutdown_free(struct LDKShutdown this_obj);
39281 export function Shutdown_free(this_obj: bigint): void {
39282 if(!isWasmInitialized) {
39283 throw new Error("initializeWasm() must be awaited first!");
39285 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
39286 // debug statements here
39288 // struct LDKChannelId Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr);
39290 export function Shutdown_get_channel_id(this_ptr: bigint): bigint {
39291 if(!isWasmInitialized) {
39292 throw new Error("initializeWasm() must be awaited first!");
39294 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
39295 return nativeResponseValue;
39297 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKChannelId val);
39299 export function Shutdown_set_channel_id(this_ptr: bigint, val: bigint): void {
39300 if(!isWasmInitialized) {
39301 throw new Error("initializeWasm() must be awaited first!");
39303 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
39304 // debug statements here
39306 // struct LDKCVec_u8Z Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
39308 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
39309 if(!isWasmInitialized) {
39310 throw new Error("initializeWasm() must be awaited first!");
39312 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
39313 return nativeResponseValue;
39315 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
39317 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
39318 if(!isWasmInitialized) {
39319 throw new Error("initializeWasm() must be awaited first!");
39321 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
39322 // debug statements here
39324 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKChannelId channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
39326 export function Shutdown_new(channel_id_arg: bigint, scriptpubkey_arg: number): bigint {
39327 if(!isWasmInitialized) {
39328 throw new Error("initializeWasm() must be awaited first!");
39330 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
39331 return nativeResponseValue;
39333 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
39335 export function Shutdown_clone_ptr(arg: bigint): bigint {
39336 if(!isWasmInitialized) {
39337 throw new Error("initializeWasm() must be awaited first!");
39339 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
39340 return nativeResponseValue;
39342 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
39344 export function Shutdown_clone(orig: bigint): bigint {
39345 if(!isWasmInitialized) {
39346 throw new Error("initializeWasm() must be awaited first!");
39348 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
39349 return nativeResponseValue;
39351 // uint64_t Shutdown_hash(const struct LDKShutdown *NONNULL_PTR o);
39353 export function Shutdown_hash(o: bigint): bigint {
39354 if(!isWasmInitialized) {
39355 throw new Error("initializeWasm() must be awaited first!");
39357 const nativeResponseValue = wasm.TS_Shutdown_hash(o);
39358 return nativeResponseValue;
39360 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
39362 export function Shutdown_eq(a: bigint, b: bigint): boolean {
39363 if(!isWasmInitialized) {
39364 throw new Error("initializeWasm() must be awaited first!");
39366 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
39367 return nativeResponseValue;
39369 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
39371 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
39372 if(!isWasmInitialized) {
39373 throw new Error("initializeWasm() must be awaited first!");
39375 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
39376 // debug statements here
39378 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
39380 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
39381 if(!isWasmInitialized) {
39382 throw new Error("initializeWasm() must be awaited first!");
39384 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
39385 return nativeResponseValue;
39387 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
39389 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
39390 if(!isWasmInitialized) {
39391 throw new Error("initializeWasm() must be awaited first!");
39393 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
39394 // debug statements here
39396 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
39398 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
39399 if(!isWasmInitialized) {
39400 throw new Error("initializeWasm() must be awaited first!");
39402 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
39403 return nativeResponseValue;
39405 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
39407 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
39408 if(!isWasmInitialized) {
39409 throw new Error("initializeWasm() must be awaited first!");
39411 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
39412 // debug statements here
39414 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
39416 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
39417 if(!isWasmInitialized) {
39418 throw new Error("initializeWasm() must be awaited first!");
39420 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
39421 return nativeResponseValue;
39423 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
39425 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
39426 if(!isWasmInitialized) {
39427 throw new Error("initializeWasm() must be awaited first!");
39429 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
39430 return nativeResponseValue;
39432 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
39434 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
39435 if(!isWasmInitialized) {
39436 throw new Error("initializeWasm() must be awaited first!");
39438 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
39439 return nativeResponseValue;
39441 // uint64_t ClosingSignedFeeRange_hash(const struct LDKClosingSignedFeeRange *NONNULL_PTR o);
39443 export function ClosingSignedFeeRange_hash(o: bigint): bigint {
39444 if(!isWasmInitialized) {
39445 throw new Error("initializeWasm() must be awaited first!");
39447 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_hash(o);
39448 return nativeResponseValue;
39450 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
39452 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
39453 if(!isWasmInitialized) {
39454 throw new Error("initializeWasm() must be awaited first!");
39456 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
39457 return nativeResponseValue;
39459 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
39461 export function ClosingSigned_free(this_obj: bigint): void {
39462 if(!isWasmInitialized) {
39463 throw new Error("initializeWasm() must be awaited first!");
39465 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
39466 // debug statements here
39468 // struct LDKChannelId ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
39470 export function ClosingSigned_get_channel_id(this_ptr: bigint): bigint {
39471 if(!isWasmInitialized) {
39472 throw new Error("initializeWasm() must be awaited first!");
39474 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
39475 return nativeResponseValue;
39477 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKChannelId val);
39479 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: bigint): void {
39480 if(!isWasmInitialized) {
39481 throw new Error("initializeWasm() must be awaited first!");
39483 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
39484 // debug statements here
39486 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
39488 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
39489 if(!isWasmInitialized) {
39490 throw new Error("initializeWasm() must be awaited first!");
39492 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
39493 return nativeResponseValue;
39495 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
39497 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
39498 if(!isWasmInitialized) {
39499 throw new Error("initializeWasm() must be awaited first!");
39501 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
39502 // debug statements here
39504 // struct LDKECDSASignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
39506 export function ClosingSigned_get_signature(this_ptr: bigint): number {
39507 if(!isWasmInitialized) {
39508 throw new Error("initializeWasm() must be awaited first!");
39510 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
39511 return nativeResponseValue;
39513 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
39515 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
39516 if(!isWasmInitialized) {
39517 throw new Error("initializeWasm() must be awaited first!");
39519 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
39520 // debug statements here
39522 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
39524 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
39525 if(!isWasmInitialized) {
39526 throw new Error("initializeWasm() must be awaited first!");
39528 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
39529 return nativeResponseValue;
39531 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
39533 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
39534 if(!isWasmInitialized) {
39535 throw new Error("initializeWasm() must be awaited first!");
39537 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
39538 // debug statements here
39540 // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKChannelId channel_id_arg, uint64_t fee_satoshis_arg, struct LDKECDSASignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
39542 export function ClosingSigned_new(channel_id_arg: bigint, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
39543 if(!isWasmInitialized) {
39544 throw new Error("initializeWasm() must be awaited first!");
39546 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
39547 return nativeResponseValue;
39549 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
39551 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
39552 if(!isWasmInitialized) {
39553 throw new Error("initializeWasm() must be awaited first!");
39555 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
39556 return nativeResponseValue;
39558 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
39560 export function ClosingSigned_clone(orig: bigint): bigint {
39561 if(!isWasmInitialized) {
39562 throw new Error("initializeWasm() must be awaited first!");
39564 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
39565 return nativeResponseValue;
39567 // uint64_t ClosingSigned_hash(const struct LDKClosingSigned *NONNULL_PTR o);
39569 export function ClosingSigned_hash(o: bigint): bigint {
39570 if(!isWasmInitialized) {
39571 throw new Error("initializeWasm() must be awaited first!");
39573 const nativeResponseValue = wasm.TS_ClosingSigned_hash(o);
39574 return nativeResponseValue;
39576 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
39578 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
39579 if(!isWasmInitialized) {
39580 throw new Error("initializeWasm() must be awaited first!");
39582 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
39583 return nativeResponseValue;
39585 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
39587 export function UpdateAddHTLC_free(this_obj: bigint): void {
39588 if(!isWasmInitialized) {
39589 throw new Error("initializeWasm() must be awaited first!");
39591 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
39592 // debug statements here
39594 // struct LDKChannelId UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39596 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): bigint {
39597 if(!isWasmInitialized) {
39598 throw new Error("initializeWasm() must be awaited first!");
39600 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
39601 return nativeResponseValue;
39603 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKChannelId val);
39605 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: bigint): void {
39606 if(!isWasmInitialized) {
39607 throw new Error("initializeWasm() must be awaited first!");
39609 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
39610 // debug statements here
39612 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39614 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
39615 if(!isWasmInitialized) {
39616 throw new Error("initializeWasm() must be awaited first!");
39618 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
39619 return nativeResponseValue;
39621 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
39623 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
39624 if(!isWasmInitialized) {
39625 throw new Error("initializeWasm() must be awaited first!");
39627 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
39628 // debug statements here
39630 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39632 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
39633 if(!isWasmInitialized) {
39634 throw new Error("initializeWasm() must be awaited first!");
39636 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
39637 return nativeResponseValue;
39639 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
39641 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
39642 if(!isWasmInitialized) {
39643 throw new Error("initializeWasm() must be awaited first!");
39645 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
39646 // debug statements here
39648 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
39650 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
39651 if(!isWasmInitialized) {
39652 throw new Error("initializeWasm() must be awaited first!");
39654 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
39655 return nativeResponseValue;
39657 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39659 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
39660 if(!isWasmInitialized) {
39661 throw new Error("initializeWasm() must be awaited first!");
39663 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
39664 // debug statements here
39666 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39668 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
39669 if(!isWasmInitialized) {
39670 throw new Error("initializeWasm() must be awaited first!");
39672 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
39673 return nativeResponseValue;
39675 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
39677 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
39678 if(!isWasmInitialized) {
39679 throw new Error("initializeWasm() must be awaited first!");
39681 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
39682 // debug statements here
39684 // struct LDKCOption_u64Z UpdateAddHTLC_get_skimmed_fee_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39686 export function UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: bigint): bigint {
39687 if(!isWasmInitialized) {
39688 throw new Error("initializeWasm() must be awaited first!");
39690 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_skimmed_fee_msat(this_ptr);
39691 return nativeResponseValue;
39693 // void UpdateAddHTLC_set_skimmed_fee_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
39695 export function UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
39696 if(!isWasmInitialized) {
39697 throw new Error("initializeWasm() must be awaited first!");
39699 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_skimmed_fee_msat(this_ptr, val);
39700 // debug statements here
39702 // struct LDKOnionPacket UpdateAddHTLC_get_onion_routing_packet(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39704 export function UpdateAddHTLC_get_onion_routing_packet(this_ptr: bigint): bigint {
39705 if(!isWasmInitialized) {
39706 throw new Error("initializeWasm() must be awaited first!");
39708 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_onion_routing_packet(this_ptr);
39709 return nativeResponseValue;
39711 // void UpdateAddHTLC_set_onion_routing_packet(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKOnionPacket val);
39713 export function UpdateAddHTLC_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
39714 if(!isWasmInitialized) {
39715 throw new Error("initializeWasm() must be awaited first!");
39717 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_onion_routing_packet(this_ptr, val);
39718 // debug statements here
39720 // struct LDKPublicKey UpdateAddHTLC_get_blinding_point(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
39722 export function UpdateAddHTLC_get_blinding_point(this_ptr: bigint): number {
39723 if(!isWasmInitialized) {
39724 throw new Error("initializeWasm() must be awaited first!");
39726 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_blinding_point(this_ptr);
39727 return nativeResponseValue;
39729 // void UpdateAddHTLC_set_blinding_point(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKPublicKey val);
39731 export function UpdateAddHTLC_set_blinding_point(this_ptr: bigint, val: number): void {
39732 if(!isWasmInitialized) {
39733 throw new Error("initializeWasm() must be awaited first!");
39735 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_blinding_point(this_ptr, val);
39736 // debug statements here
39738 // MUST_USE_RES struct LDKUpdateAddHTLC UpdateAddHTLC_new(struct LDKChannelId channel_id_arg, uint64_t htlc_id_arg, uint64_t amount_msat_arg, struct LDKThirtyTwoBytes payment_hash_arg, uint32_t cltv_expiry_arg, struct LDKCOption_u64Z skimmed_fee_msat_arg, struct LDKOnionPacket onion_routing_packet_arg, struct LDKPublicKey blinding_point_arg);
39740 export function UpdateAddHTLC_new(channel_id_arg: bigint, htlc_id_arg: bigint, amount_msat_arg: bigint, payment_hash_arg: number, cltv_expiry_arg: number, skimmed_fee_msat_arg: bigint, onion_routing_packet_arg: bigint, blinding_point_arg: number): bigint {
39741 if(!isWasmInitialized) {
39742 throw new Error("initializeWasm() must be awaited first!");
39744 const nativeResponseValue = wasm.TS_UpdateAddHTLC_new(channel_id_arg, htlc_id_arg, amount_msat_arg, payment_hash_arg, cltv_expiry_arg, skimmed_fee_msat_arg, onion_routing_packet_arg, blinding_point_arg);
39745 return nativeResponseValue;
39747 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
39749 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
39750 if(!isWasmInitialized) {
39751 throw new Error("initializeWasm() must be awaited first!");
39753 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
39754 return nativeResponseValue;
39756 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
39758 export function UpdateAddHTLC_clone(orig: bigint): bigint {
39759 if(!isWasmInitialized) {
39760 throw new Error("initializeWasm() must be awaited first!");
39762 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
39763 return nativeResponseValue;
39765 // uint64_t UpdateAddHTLC_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR o);
39767 export function UpdateAddHTLC_hash(o: bigint): bigint {
39768 if(!isWasmInitialized) {
39769 throw new Error("initializeWasm() must be awaited first!");
39771 const nativeResponseValue = wasm.TS_UpdateAddHTLC_hash(o);
39772 return nativeResponseValue;
39774 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
39776 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
39777 if(!isWasmInitialized) {
39778 throw new Error("initializeWasm() must be awaited first!");
39780 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
39781 return nativeResponseValue;
39783 // void OnionMessage_free(struct LDKOnionMessage this_obj);
39785 export function OnionMessage_free(this_obj: bigint): void {
39786 if(!isWasmInitialized) {
39787 throw new Error("initializeWasm() must be awaited first!");
39789 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
39790 // debug statements here
39792 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
39794 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
39795 if(!isWasmInitialized) {
39796 throw new Error("initializeWasm() must be awaited first!");
39798 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
39799 return nativeResponseValue;
39801 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
39803 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
39804 if(!isWasmInitialized) {
39805 throw new Error("initializeWasm() must be awaited first!");
39807 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
39808 // debug statements here
39810 // struct LDKPacket OnionMessage_get_onion_routing_packet(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
39812 export function OnionMessage_get_onion_routing_packet(this_ptr: bigint): bigint {
39813 if(!isWasmInitialized) {
39814 throw new Error("initializeWasm() must be awaited first!");
39816 const nativeResponseValue = wasm.TS_OnionMessage_get_onion_routing_packet(this_ptr);
39817 return nativeResponseValue;
39819 // void OnionMessage_set_onion_routing_packet(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPacket val);
39821 export function OnionMessage_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
39822 if(!isWasmInitialized) {
39823 throw new Error("initializeWasm() must be awaited first!");
39825 const nativeResponseValue = wasm.TS_OnionMessage_set_onion_routing_packet(this_ptr, val);
39826 // debug statements here
39828 // MUST_USE_RES struct LDKOnionMessage OnionMessage_new(struct LDKPublicKey blinding_point_arg, struct LDKPacket onion_routing_packet_arg);
39830 export function OnionMessage_new(blinding_point_arg: number, onion_routing_packet_arg: bigint): bigint {
39831 if(!isWasmInitialized) {
39832 throw new Error("initializeWasm() must be awaited first!");
39834 const nativeResponseValue = wasm.TS_OnionMessage_new(blinding_point_arg, onion_routing_packet_arg);
39835 return nativeResponseValue;
39837 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
39839 export function OnionMessage_clone_ptr(arg: bigint): bigint {
39840 if(!isWasmInitialized) {
39841 throw new Error("initializeWasm() must be awaited first!");
39843 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
39844 return nativeResponseValue;
39846 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
39848 export function OnionMessage_clone(orig: bigint): bigint {
39849 if(!isWasmInitialized) {
39850 throw new Error("initializeWasm() must be awaited first!");
39852 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
39853 return nativeResponseValue;
39855 // uint64_t OnionMessage_hash(const struct LDKOnionMessage *NONNULL_PTR o);
39857 export function OnionMessage_hash(o: bigint): bigint {
39858 if(!isWasmInitialized) {
39859 throw new Error("initializeWasm() must be awaited first!");
39861 const nativeResponseValue = wasm.TS_OnionMessage_hash(o);
39862 return nativeResponseValue;
39864 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
39866 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
39867 if(!isWasmInitialized) {
39868 throw new Error("initializeWasm() must be awaited first!");
39870 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
39871 return nativeResponseValue;
39873 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
39875 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
39876 if(!isWasmInitialized) {
39877 throw new Error("initializeWasm() must be awaited first!");
39879 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
39880 // debug statements here
39882 // struct LDKChannelId UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
39884 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): bigint {
39885 if(!isWasmInitialized) {
39886 throw new Error("initializeWasm() must be awaited first!");
39888 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
39889 return nativeResponseValue;
39891 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKChannelId val);
39893 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: bigint): void {
39894 if(!isWasmInitialized) {
39895 throw new Error("initializeWasm() must be awaited first!");
39897 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
39898 // debug statements here
39900 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
39902 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
39903 if(!isWasmInitialized) {
39904 throw new Error("initializeWasm() must be awaited first!");
39906 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
39907 return nativeResponseValue;
39909 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
39911 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
39912 if(!isWasmInitialized) {
39913 throw new Error("initializeWasm() must be awaited first!");
39915 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
39916 // debug statements here
39918 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
39920 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
39921 if(!isWasmInitialized) {
39922 throw new Error("initializeWasm() must be awaited first!");
39924 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
39925 return nativeResponseValue;
39927 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39929 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
39930 if(!isWasmInitialized) {
39931 throw new Error("initializeWasm() must be awaited first!");
39933 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
39934 // debug statements here
39936 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKChannelId channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
39938 export function UpdateFulfillHTLC_new(channel_id_arg: bigint, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
39939 if(!isWasmInitialized) {
39940 throw new Error("initializeWasm() must be awaited first!");
39942 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
39943 return nativeResponseValue;
39945 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
39947 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
39948 if(!isWasmInitialized) {
39949 throw new Error("initializeWasm() must be awaited first!");
39951 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
39952 return nativeResponseValue;
39954 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
39956 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
39957 if(!isWasmInitialized) {
39958 throw new Error("initializeWasm() must be awaited first!");
39960 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
39961 return nativeResponseValue;
39963 // uint64_t UpdateFulfillHTLC_hash(const struct LDKUpdateFulfillHTLC *NONNULL_PTR o);
39965 export function UpdateFulfillHTLC_hash(o: bigint): bigint {
39966 if(!isWasmInitialized) {
39967 throw new Error("initializeWasm() must be awaited first!");
39969 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_hash(o);
39970 return nativeResponseValue;
39972 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
39974 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
39975 if(!isWasmInitialized) {
39976 throw new Error("initializeWasm() must be awaited first!");
39978 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
39979 return nativeResponseValue;
39981 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
39983 export function UpdateFailHTLC_free(this_obj: bigint): void {
39984 if(!isWasmInitialized) {
39985 throw new Error("initializeWasm() must be awaited first!");
39987 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
39988 // debug statements here
39990 // struct LDKChannelId UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
39992 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): bigint {
39993 if(!isWasmInitialized) {
39994 throw new Error("initializeWasm() must be awaited first!");
39996 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
39997 return nativeResponseValue;
39999 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKChannelId val);
40001 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: bigint): void {
40002 if(!isWasmInitialized) {
40003 throw new Error("initializeWasm() must be awaited first!");
40005 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
40006 // debug statements here
40008 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
40010 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
40011 if(!isWasmInitialized) {
40012 throw new Error("initializeWasm() must be awaited first!");
40014 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
40015 return nativeResponseValue;
40017 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
40019 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
40020 if(!isWasmInitialized) {
40021 throw new Error("initializeWasm() must be awaited first!");
40023 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
40024 // debug statements here
40026 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
40028 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
40029 if(!isWasmInitialized) {
40030 throw new Error("initializeWasm() must be awaited first!");
40032 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
40033 return nativeResponseValue;
40035 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
40037 export function UpdateFailHTLC_clone(orig: bigint): bigint {
40038 if(!isWasmInitialized) {
40039 throw new Error("initializeWasm() must be awaited first!");
40041 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
40042 return nativeResponseValue;
40044 // uint64_t UpdateFailHTLC_hash(const struct LDKUpdateFailHTLC *NONNULL_PTR o);
40046 export function UpdateFailHTLC_hash(o: bigint): bigint {
40047 if(!isWasmInitialized) {
40048 throw new Error("initializeWasm() must be awaited first!");
40050 const nativeResponseValue = wasm.TS_UpdateFailHTLC_hash(o);
40051 return nativeResponseValue;
40053 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
40055 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
40056 if(!isWasmInitialized) {
40057 throw new Error("initializeWasm() must be awaited first!");
40059 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
40060 return nativeResponseValue;
40062 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
40064 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
40065 if(!isWasmInitialized) {
40066 throw new Error("initializeWasm() must be awaited first!");
40068 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
40069 // debug statements here
40071 // struct LDKChannelId UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
40073 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): bigint {
40074 if(!isWasmInitialized) {
40075 throw new Error("initializeWasm() must be awaited first!");
40077 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
40078 return nativeResponseValue;
40080 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKChannelId val);
40082 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: bigint): void {
40083 if(!isWasmInitialized) {
40084 throw new Error("initializeWasm() must be awaited first!");
40086 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
40087 // debug statements here
40089 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
40091 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
40092 if(!isWasmInitialized) {
40093 throw new Error("initializeWasm() must be awaited first!");
40095 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
40096 return nativeResponseValue;
40098 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
40100 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
40101 if(!isWasmInitialized) {
40102 throw new Error("initializeWasm() must be awaited first!");
40104 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
40105 // debug statements here
40107 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
40109 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
40110 if(!isWasmInitialized) {
40111 throw new Error("initializeWasm() must be awaited first!");
40113 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
40114 return nativeResponseValue;
40116 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
40118 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
40119 if(!isWasmInitialized) {
40120 throw new Error("initializeWasm() must be awaited first!");
40122 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
40123 // debug statements here
40125 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
40127 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
40128 if(!isWasmInitialized) {
40129 throw new Error("initializeWasm() must be awaited first!");
40131 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
40132 return nativeResponseValue;
40134 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
40136 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
40137 if(!isWasmInitialized) {
40138 throw new Error("initializeWasm() must be awaited first!");
40140 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
40141 return nativeResponseValue;
40143 // uint64_t UpdateFailMalformedHTLC_hash(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR o);
40145 export function UpdateFailMalformedHTLC_hash(o: bigint): bigint {
40146 if(!isWasmInitialized) {
40147 throw new Error("initializeWasm() must be awaited first!");
40149 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_hash(o);
40150 return nativeResponseValue;
40152 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
40154 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
40155 if(!isWasmInitialized) {
40156 throw new Error("initializeWasm() must be awaited first!");
40158 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
40159 return nativeResponseValue;
40161 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
40163 export function CommitmentSigned_free(this_obj: bigint): void {
40164 if(!isWasmInitialized) {
40165 throw new Error("initializeWasm() must be awaited first!");
40167 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
40168 // debug statements here
40170 // struct LDKChannelId CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
40172 export function CommitmentSigned_get_channel_id(this_ptr: bigint): bigint {
40173 if(!isWasmInitialized) {
40174 throw new Error("initializeWasm() must be awaited first!");
40176 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
40177 return nativeResponseValue;
40179 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKChannelId val);
40181 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: bigint): void {
40182 if(!isWasmInitialized) {
40183 throw new Error("initializeWasm() must be awaited first!");
40185 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
40186 // debug statements here
40188 // struct LDKECDSASignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
40190 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
40191 if(!isWasmInitialized) {
40192 throw new Error("initializeWasm() must be awaited first!");
40194 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
40195 return nativeResponseValue;
40197 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
40199 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
40200 if(!isWasmInitialized) {
40201 throw new Error("initializeWasm() must be awaited first!");
40203 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
40204 // debug statements here
40206 // struct LDKCVec_ECDSASignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
40208 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
40209 if(!isWasmInitialized) {
40210 throw new Error("initializeWasm() must be awaited first!");
40212 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
40213 return nativeResponseValue;
40215 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
40217 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
40218 if(!isWasmInitialized) {
40219 throw new Error("initializeWasm() must be awaited first!");
40221 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
40222 // debug statements here
40224 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKChannelId channel_id_arg, struct LDKECDSASignature signature_arg, struct LDKCVec_ECDSASignatureZ htlc_signatures_arg);
40226 export function CommitmentSigned_new(channel_id_arg: bigint, signature_arg: number, htlc_signatures_arg: number): bigint {
40227 if(!isWasmInitialized) {
40228 throw new Error("initializeWasm() must be awaited first!");
40230 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
40231 return nativeResponseValue;
40233 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
40235 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
40236 if(!isWasmInitialized) {
40237 throw new Error("initializeWasm() must be awaited first!");
40239 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
40240 return nativeResponseValue;
40242 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
40244 export function CommitmentSigned_clone(orig: bigint): bigint {
40245 if(!isWasmInitialized) {
40246 throw new Error("initializeWasm() must be awaited first!");
40248 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
40249 return nativeResponseValue;
40251 // uint64_t CommitmentSigned_hash(const struct LDKCommitmentSigned *NONNULL_PTR o);
40253 export function CommitmentSigned_hash(o: bigint): bigint {
40254 if(!isWasmInitialized) {
40255 throw new Error("initializeWasm() must be awaited first!");
40257 const nativeResponseValue = wasm.TS_CommitmentSigned_hash(o);
40258 return nativeResponseValue;
40260 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
40262 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
40263 if(!isWasmInitialized) {
40264 throw new Error("initializeWasm() must be awaited first!");
40266 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
40267 return nativeResponseValue;
40269 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
40271 export function RevokeAndACK_free(this_obj: bigint): void {
40272 if(!isWasmInitialized) {
40273 throw new Error("initializeWasm() must be awaited first!");
40275 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
40276 // debug statements here
40278 // struct LDKChannelId RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
40280 export function RevokeAndACK_get_channel_id(this_ptr: bigint): bigint {
40281 if(!isWasmInitialized) {
40282 throw new Error("initializeWasm() must be awaited first!");
40284 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
40285 return nativeResponseValue;
40287 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKChannelId val);
40289 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: bigint): void {
40290 if(!isWasmInitialized) {
40291 throw new Error("initializeWasm() must be awaited first!");
40293 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
40294 // debug statements here
40296 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
40298 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
40299 if(!isWasmInitialized) {
40300 throw new Error("initializeWasm() must be awaited first!");
40302 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
40303 return nativeResponseValue;
40305 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
40307 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
40308 if(!isWasmInitialized) {
40309 throw new Error("initializeWasm() must be awaited first!");
40311 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
40312 // debug statements here
40314 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
40316 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
40317 if(!isWasmInitialized) {
40318 throw new Error("initializeWasm() must be awaited first!");
40320 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
40321 return nativeResponseValue;
40323 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
40325 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
40326 if(!isWasmInitialized) {
40327 throw new Error("initializeWasm() must be awaited first!");
40329 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
40330 // debug statements here
40332 // MUST_USE_RES struct LDKRevokeAndACK RevokeAndACK_new(struct LDKChannelId channel_id_arg, struct LDKThirtyTwoBytes per_commitment_secret_arg, struct LDKPublicKey next_per_commitment_point_arg);
40334 export function RevokeAndACK_new(channel_id_arg: bigint, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
40335 if(!isWasmInitialized) {
40336 throw new Error("initializeWasm() must be awaited first!");
40338 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
40339 return nativeResponseValue;
40341 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
40343 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
40344 if(!isWasmInitialized) {
40345 throw new Error("initializeWasm() must be awaited first!");
40347 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
40348 return nativeResponseValue;
40350 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
40352 export function RevokeAndACK_clone(orig: bigint): bigint {
40353 if(!isWasmInitialized) {
40354 throw new Error("initializeWasm() must be awaited first!");
40356 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
40357 return nativeResponseValue;
40359 // uint64_t RevokeAndACK_hash(const struct LDKRevokeAndACK *NONNULL_PTR o);
40361 export function RevokeAndACK_hash(o: bigint): bigint {
40362 if(!isWasmInitialized) {
40363 throw new Error("initializeWasm() must be awaited first!");
40365 const nativeResponseValue = wasm.TS_RevokeAndACK_hash(o);
40366 return nativeResponseValue;
40368 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
40370 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
40371 if(!isWasmInitialized) {
40372 throw new Error("initializeWasm() must be awaited first!");
40374 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
40375 return nativeResponseValue;
40377 // void UpdateFee_free(struct LDKUpdateFee this_obj);
40379 export function UpdateFee_free(this_obj: bigint): void {
40380 if(!isWasmInitialized) {
40381 throw new Error("initializeWasm() must be awaited first!");
40383 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
40384 // debug statements here
40386 // struct LDKChannelId UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
40388 export function UpdateFee_get_channel_id(this_ptr: bigint): bigint {
40389 if(!isWasmInitialized) {
40390 throw new Error("initializeWasm() must be awaited first!");
40392 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
40393 return nativeResponseValue;
40395 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKChannelId val);
40397 export function UpdateFee_set_channel_id(this_ptr: bigint, val: bigint): void {
40398 if(!isWasmInitialized) {
40399 throw new Error("initializeWasm() must be awaited first!");
40401 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
40402 // debug statements here
40404 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
40406 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
40407 if(!isWasmInitialized) {
40408 throw new Error("initializeWasm() must be awaited first!");
40410 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
40411 return nativeResponseValue;
40413 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
40415 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
40416 if(!isWasmInitialized) {
40417 throw new Error("initializeWasm() must be awaited first!");
40419 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
40420 // debug statements here
40422 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKChannelId channel_id_arg, uint32_t feerate_per_kw_arg);
40424 export function UpdateFee_new(channel_id_arg: bigint, feerate_per_kw_arg: number): bigint {
40425 if(!isWasmInitialized) {
40426 throw new Error("initializeWasm() must be awaited first!");
40428 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
40429 return nativeResponseValue;
40431 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
40433 export function UpdateFee_clone_ptr(arg: bigint): bigint {
40434 if(!isWasmInitialized) {
40435 throw new Error("initializeWasm() must be awaited first!");
40437 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
40438 return nativeResponseValue;
40440 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
40442 export function UpdateFee_clone(orig: bigint): bigint {
40443 if(!isWasmInitialized) {
40444 throw new Error("initializeWasm() must be awaited first!");
40446 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
40447 return nativeResponseValue;
40449 // uint64_t UpdateFee_hash(const struct LDKUpdateFee *NONNULL_PTR o);
40451 export function UpdateFee_hash(o: bigint): bigint {
40452 if(!isWasmInitialized) {
40453 throw new Error("initializeWasm() must be awaited first!");
40455 const nativeResponseValue = wasm.TS_UpdateFee_hash(o);
40456 return nativeResponseValue;
40458 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
40460 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
40461 if(!isWasmInitialized) {
40462 throw new Error("initializeWasm() must be awaited first!");
40464 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
40465 return nativeResponseValue;
40467 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
40469 export function ChannelReestablish_free(this_obj: bigint): void {
40470 if(!isWasmInitialized) {
40471 throw new Error("initializeWasm() must be awaited first!");
40473 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
40474 // debug statements here
40476 // struct LDKChannelId ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
40478 export function ChannelReestablish_get_channel_id(this_ptr: bigint): bigint {
40479 if(!isWasmInitialized) {
40480 throw new Error("initializeWasm() must be awaited first!");
40482 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
40483 return nativeResponseValue;
40485 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKChannelId val);
40487 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: bigint): void {
40488 if(!isWasmInitialized) {
40489 throw new Error("initializeWasm() must be awaited first!");
40491 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
40492 // debug statements here
40494 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
40496 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
40497 if(!isWasmInitialized) {
40498 throw new Error("initializeWasm() must be awaited first!");
40500 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
40501 return nativeResponseValue;
40503 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
40505 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
40506 if(!isWasmInitialized) {
40507 throw new Error("initializeWasm() must be awaited first!");
40509 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
40510 // debug statements here
40512 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
40514 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
40515 if(!isWasmInitialized) {
40516 throw new Error("initializeWasm() must be awaited first!");
40518 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
40519 return nativeResponseValue;
40521 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
40523 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
40524 if(!isWasmInitialized) {
40525 throw new Error("initializeWasm() must be awaited first!");
40527 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
40528 // debug statements here
40530 // const uint8_t (*ChannelReestablish_get_your_last_per_commitment_secret(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
40532 export function ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: bigint): number {
40533 if(!isWasmInitialized) {
40534 throw new Error("initializeWasm() must be awaited first!");
40536 const nativeResponseValue = wasm.TS_ChannelReestablish_get_your_last_per_commitment_secret(this_ptr);
40537 return nativeResponseValue;
40539 // void ChannelReestablish_set_your_last_per_commitment_secret(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
40541 export function ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
40542 if(!isWasmInitialized) {
40543 throw new Error("initializeWasm() must be awaited first!");
40545 const nativeResponseValue = wasm.TS_ChannelReestablish_set_your_last_per_commitment_secret(this_ptr, val);
40546 // debug statements here
40548 // struct LDKPublicKey ChannelReestablish_get_my_current_per_commitment_point(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
40550 export function ChannelReestablish_get_my_current_per_commitment_point(this_ptr: bigint): number {
40551 if(!isWasmInitialized) {
40552 throw new Error("initializeWasm() must be awaited first!");
40554 const nativeResponseValue = wasm.TS_ChannelReestablish_get_my_current_per_commitment_point(this_ptr);
40555 return nativeResponseValue;
40557 // void ChannelReestablish_set_my_current_per_commitment_point(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKPublicKey val);
40559 export function ChannelReestablish_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
40560 if(!isWasmInitialized) {
40561 throw new Error("initializeWasm() must be awaited first!");
40563 const nativeResponseValue = wasm.TS_ChannelReestablish_set_my_current_per_commitment_point(this_ptr, val);
40564 // debug statements here
40566 // struct LDKCOption_ThirtyTwoBytesZ ChannelReestablish_get_next_funding_txid(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
40568 export function ChannelReestablish_get_next_funding_txid(this_ptr: bigint): bigint {
40569 if(!isWasmInitialized) {
40570 throw new Error("initializeWasm() must be awaited first!");
40572 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_funding_txid(this_ptr);
40573 return nativeResponseValue;
40575 // void ChannelReestablish_set_next_funding_txid(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
40577 export function ChannelReestablish_set_next_funding_txid(this_ptr: bigint, val: bigint): void {
40578 if(!isWasmInitialized) {
40579 throw new Error("initializeWasm() must be awaited first!");
40581 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_funding_txid(this_ptr, val);
40582 // debug statements here
40584 // MUST_USE_RES struct LDKChannelReestablish ChannelReestablish_new(struct LDKChannelId channel_id_arg, uint64_t next_local_commitment_number_arg, uint64_t next_remote_commitment_number_arg, struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg, struct LDKCOption_ThirtyTwoBytesZ next_funding_txid_arg);
40586 export function ChannelReestablish_new(channel_id_arg: bigint, next_local_commitment_number_arg: bigint, next_remote_commitment_number_arg: bigint, your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number, next_funding_txid_arg: bigint): bigint {
40587 if(!isWasmInitialized) {
40588 throw new Error("initializeWasm() must be awaited first!");
40590 const nativeResponseValue = wasm.TS_ChannelReestablish_new(channel_id_arg, next_local_commitment_number_arg, next_remote_commitment_number_arg, your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg, next_funding_txid_arg);
40591 return nativeResponseValue;
40593 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
40595 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
40596 if(!isWasmInitialized) {
40597 throw new Error("initializeWasm() must be awaited first!");
40599 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
40600 return nativeResponseValue;
40602 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
40604 export function ChannelReestablish_clone(orig: bigint): bigint {
40605 if(!isWasmInitialized) {
40606 throw new Error("initializeWasm() must be awaited first!");
40608 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
40609 return nativeResponseValue;
40611 // uint64_t ChannelReestablish_hash(const struct LDKChannelReestablish *NONNULL_PTR o);
40613 export function ChannelReestablish_hash(o: bigint): bigint {
40614 if(!isWasmInitialized) {
40615 throw new Error("initializeWasm() must be awaited first!");
40617 const nativeResponseValue = wasm.TS_ChannelReestablish_hash(o);
40618 return nativeResponseValue;
40620 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
40622 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
40623 if(!isWasmInitialized) {
40624 throw new Error("initializeWasm() must be awaited first!");
40626 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
40627 return nativeResponseValue;
40629 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
40631 export function AnnouncementSignatures_free(this_obj: bigint): void {
40632 if(!isWasmInitialized) {
40633 throw new Error("initializeWasm() must be awaited first!");
40635 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
40636 // debug statements here
40638 // struct LDKChannelId AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
40640 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): bigint {
40641 if(!isWasmInitialized) {
40642 throw new Error("initializeWasm() must be awaited first!");
40644 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
40645 return nativeResponseValue;
40647 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKChannelId val);
40649 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: bigint): void {
40650 if(!isWasmInitialized) {
40651 throw new Error("initializeWasm() must be awaited first!");
40653 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
40654 // debug statements here
40656 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
40658 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
40659 if(!isWasmInitialized) {
40660 throw new Error("initializeWasm() must be awaited first!");
40662 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
40663 return nativeResponseValue;
40665 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
40667 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
40668 if(!isWasmInitialized) {
40669 throw new Error("initializeWasm() must be awaited first!");
40671 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
40672 // debug statements here
40674 // struct LDKECDSASignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
40676 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
40677 if(!isWasmInitialized) {
40678 throw new Error("initializeWasm() must be awaited first!");
40680 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
40681 return nativeResponseValue;
40683 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
40685 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
40686 if(!isWasmInitialized) {
40687 throw new Error("initializeWasm() must be awaited first!");
40689 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
40690 // debug statements here
40692 // struct LDKECDSASignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
40694 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
40695 if(!isWasmInitialized) {
40696 throw new Error("initializeWasm() must be awaited first!");
40698 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
40699 return nativeResponseValue;
40701 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
40703 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
40704 if(!isWasmInitialized) {
40705 throw new Error("initializeWasm() must be awaited first!");
40707 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
40708 // debug statements here
40710 // MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKChannelId channel_id_arg, uint64_t short_channel_id_arg, struct LDKECDSASignature node_signature_arg, struct LDKECDSASignature bitcoin_signature_arg);
40712 export function AnnouncementSignatures_new(channel_id_arg: bigint, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
40713 if(!isWasmInitialized) {
40714 throw new Error("initializeWasm() must be awaited first!");
40716 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
40717 return nativeResponseValue;
40719 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
40721 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
40722 if(!isWasmInitialized) {
40723 throw new Error("initializeWasm() must be awaited first!");
40725 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
40726 return nativeResponseValue;
40728 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
40730 export function AnnouncementSignatures_clone(orig: bigint): bigint {
40731 if(!isWasmInitialized) {
40732 throw new Error("initializeWasm() must be awaited first!");
40734 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
40735 return nativeResponseValue;
40737 // uint64_t AnnouncementSignatures_hash(const struct LDKAnnouncementSignatures *NONNULL_PTR o);
40739 export function AnnouncementSignatures_hash(o: bigint): bigint {
40740 if(!isWasmInitialized) {
40741 throw new Error("initializeWasm() must be awaited first!");
40743 const nativeResponseValue = wasm.TS_AnnouncementSignatures_hash(o);
40744 return nativeResponseValue;
40746 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
40748 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
40749 if(!isWasmInitialized) {
40750 throw new Error("initializeWasm() must be awaited first!");
40752 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
40753 return nativeResponseValue;
40755 // void SocketAddress_free(struct LDKSocketAddress this_ptr);
40757 export function SocketAddress_free(this_ptr: bigint): void {
40758 if(!isWasmInitialized) {
40759 throw new Error("initializeWasm() must be awaited first!");
40761 const nativeResponseValue = wasm.TS_SocketAddress_free(this_ptr);
40762 // debug statements here
40764 // uint64_t SocketAddress_clone_ptr(LDKSocketAddress *NONNULL_PTR arg);
40766 export function SocketAddress_clone_ptr(arg: bigint): bigint {
40767 if(!isWasmInitialized) {
40768 throw new Error("initializeWasm() must be awaited first!");
40770 const nativeResponseValue = wasm.TS_SocketAddress_clone_ptr(arg);
40771 return nativeResponseValue;
40773 // struct LDKSocketAddress SocketAddress_clone(const struct LDKSocketAddress *NONNULL_PTR orig);
40775 export function SocketAddress_clone(orig: bigint): bigint {
40776 if(!isWasmInitialized) {
40777 throw new Error("initializeWasm() must be awaited first!");
40779 const nativeResponseValue = wasm.TS_SocketAddress_clone(orig);
40780 return nativeResponseValue;
40782 // struct LDKSocketAddress SocketAddress_tcp_ip_v4(struct LDKFourBytes addr, uint16_t port);
40784 export function SocketAddress_tcp_ip_v4(addr: number, port: number): bigint {
40785 if(!isWasmInitialized) {
40786 throw new Error("initializeWasm() must be awaited first!");
40788 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v4(addr, port);
40789 return nativeResponseValue;
40791 // struct LDKSocketAddress SocketAddress_tcp_ip_v6(struct LDKSixteenBytes addr, uint16_t port);
40793 export function SocketAddress_tcp_ip_v6(addr: number, port: number): bigint {
40794 if(!isWasmInitialized) {
40795 throw new Error("initializeWasm() must be awaited first!");
40797 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v6(addr, port);
40798 return nativeResponseValue;
40800 // struct LDKSocketAddress SocketAddress_onion_v2(struct LDKTwelveBytes a);
40802 export function SocketAddress_onion_v2(a: number): bigint {
40803 if(!isWasmInitialized) {
40804 throw new Error("initializeWasm() must be awaited first!");
40806 const nativeResponseValue = wasm.TS_SocketAddress_onion_v2(a);
40807 return nativeResponseValue;
40809 // struct LDKSocketAddress SocketAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
40811 export function SocketAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
40812 if(!isWasmInitialized) {
40813 throw new Error("initializeWasm() must be awaited first!");
40815 const nativeResponseValue = wasm.TS_SocketAddress_onion_v3(ed25519_pubkey, checksum, version, port);
40816 return nativeResponseValue;
40818 // struct LDKSocketAddress SocketAddress_hostname(struct LDKHostname hostname, uint16_t port);
40820 export function SocketAddress_hostname(hostname: bigint, port: number): bigint {
40821 if(!isWasmInitialized) {
40822 throw new Error("initializeWasm() must be awaited first!");
40824 const nativeResponseValue = wasm.TS_SocketAddress_hostname(hostname, port);
40825 return nativeResponseValue;
40827 // uint64_t SocketAddress_hash(const struct LDKSocketAddress *NONNULL_PTR o);
40829 export function SocketAddress_hash(o: bigint): bigint {
40830 if(!isWasmInitialized) {
40831 throw new Error("initializeWasm() must be awaited first!");
40833 const nativeResponseValue = wasm.TS_SocketAddress_hash(o);
40834 return nativeResponseValue;
40836 // bool SocketAddress_eq(const struct LDKSocketAddress *NONNULL_PTR a, const struct LDKSocketAddress *NONNULL_PTR b);
40838 export function SocketAddress_eq(a: bigint, b: bigint): boolean {
40839 if(!isWasmInitialized) {
40840 throw new Error("initializeWasm() must be awaited first!");
40842 const nativeResponseValue = wasm.TS_SocketAddress_eq(a, b);
40843 return nativeResponseValue;
40845 // struct LDKCVec_u8Z SocketAddress_write(const struct LDKSocketAddress *NONNULL_PTR obj);
40847 export function SocketAddress_write(obj: bigint): number {
40848 if(!isWasmInitialized) {
40849 throw new Error("initializeWasm() must be awaited first!");
40851 const nativeResponseValue = wasm.TS_SocketAddress_write(obj);
40852 return nativeResponseValue;
40854 // struct LDKCResult_SocketAddressDecodeErrorZ SocketAddress_read(struct LDKu8slice ser);
40856 export function SocketAddress_read(ser: number): bigint {
40857 if(!isWasmInitialized) {
40858 throw new Error("initializeWasm() must be awaited first!");
40860 const nativeResponseValue = wasm.TS_SocketAddress_read(ser);
40861 return nativeResponseValue;
40863 // enum LDKSocketAddressParseError SocketAddressParseError_clone(const enum LDKSocketAddressParseError *NONNULL_PTR orig);
40865 export function SocketAddressParseError_clone(orig: bigint): SocketAddressParseError {
40866 if(!isWasmInitialized) {
40867 throw new Error("initializeWasm() must be awaited first!");
40869 const nativeResponseValue = wasm.TS_SocketAddressParseError_clone(orig);
40870 return nativeResponseValue;
40872 // enum LDKSocketAddressParseError SocketAddressParseError_socket_addr_parse(void);
40874 export function SocketAddressParseError_socket_addr_parse(): SocketAddressParseError {
40875 if(!isWasmInitialized) {
40876 throw new Error("initializeWasm() must be awaited first!");
40878 const nativeResponseValue = wasm.TS_SocketAddressParseError_socket_addr_parse();
40879 return nativeResponseValue;
40881 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_input(void);
40883 export function SocketAddressParseError_invalid_input(): SocketAddressParseError {
40884 if(!isWasmInitialized) {
40885 throw new Error("initializeWasm() must be awaited first!");
40887 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_input();
40888 return nativeResponseValue;
40890 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_port(void);
40892 export function SocketAddressParseError_invalid_port(): SocketAddressParseError {
40893 if(!isWasmInitialized) {
40894 throw new Error("initializeWasm() must be awaited first!");
40896 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_port();
40897 return nativeResponseValue;
40899 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_onion_v3(void);
40901 export function SocketAddressParseError_invalid_onion_v3(): SocketAddressParseError {
40902 if(!isWasmInitialized) {
40903 throw new Error("initializeWasm() must be awaited first!");
40905 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_onion_v3();
40906 return nativeResponseValue;
40908 // uint64_t SocketAddressParseError_hash(const enum LDKSocketAddressParseError *NONNULL_PTR o);
40910 export function SocketAddressParseError_hash(o: bigint): bigint {
40911 if(!isWasmInitialized) {
40912 throw new Error("initializeWasm() must be awaited first!");
40914 const nativeResponseValue = wasm.TS_SocketAddressParseError_hash(o);
40915 return nativeResponseValue;
40917 // bool SocketAddressParseError_eq(const enum LDKSocketAddressParseError *NONNULL_PTR a, const enum LDKSocketAddressParseError *NONNULL_PTR b);
40919 export function SocketAddressParseError_eq(a: bigint, b: bigint): boolean {
40920 if(!isWasmInitialized) {
40921 throw new Error("initializeWasm() must be awaited first!");
40923 const nativeResponseValue = wasm.TS_SocketAddressParseError_eq(a, b);
40924 return nativeResponseValue;
40926 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ parse_onion_address(struct LDKStr host, uint16_t port);
40928 export function parse_onion_address(host: number, port: number): bigint {
40929 if(!isWasmInitialized) {
40930 throw new Error("initializeWasm() must be awaited first!");
40932 const nativeResponseValue = wasm.TS_parse_onion_address(host, port);
40933 return nativeResponseValue;
40935 // struct LDKStr SocketAddress_to_str(const struct LDKSocketAddress *NONNULL_PTR o);
40937 export function SocketAddress_to_str(o: bigint): number {
40938 if(!isWasmInitialized) {
40939 throw new Error("initializeWasm() must be awaited first!");
40941 const nativeResponseValue = wasm.TS_SocketAddress_to_str(o);
40942 return nativeResponseValue;
40944 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
40946 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
40947 if(!isWasmInitialized) {
40948 throw new Error("initializeWasm() must be awaited first!");
40950 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
40951 // debug statements here
40953 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
40955 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
40956 if(!isWasmInitialized) {
40957 throw new Error("initializeWasm() must be awaited first!");
40959 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
40960 return nativeResponseValue;
40962 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
40964 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
40965 if(!isWasmInitialized) {
40966 throw new Error("initializeWasm() must be awaited first!");
40968 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
40969 return nativeResponseValue;
40971 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
40973 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
40974 if(!isWasmInitialized) {
40975 throw new Error("initializeWasm() must be awaited first!");
40977 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
40978 return nativeResponseValue;
40980 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
40982 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
40983 if(!isWasmInitialized) {
40984 throw new Error("initializeWasm() must be awaited first!");
40986 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
40987 return nativeResponseValue;
40989 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
40991 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
40992 if(!isWasmInitialized) {
40993 throw new Error("initializeWasm() must be awaited first!");
40995 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
40996 return nativeResponseValue;
40998 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
41000 export function UnsignedGossipMessage_write(obj: bigint): number {
41001 if(!isWasmInitialized) {
41002 throw new Error("initializeWasm() must be awaited first!");
41004 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
41005 return nativeResponseValue;
41007 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
41009 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
41010 if(!isWasmInitialized) {
41011 throw new Error("initializeWasm() must be awaited first!");
41013 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
41014 // debug statements here
41016 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41018 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
41019 if(!isWasmInitialized) {
41020 throw new Error("initializeWasm() must be awaited first!");
41022 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
41023 return nativeResponseValue;
41025 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
41027 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
41028 if(!isWasmInitialized) {
41029 throw new Error("initializeWasm() must be awaited first!");
41031 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
41032 // debug statements here
41034 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41036 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
41037 if(!isWasmInitialized) {
41038 throw new Error("initializeWasm() must be awaited first!");
41040 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
41041 return nativeResponseValue;
41043 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
41045 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
41046 if(!isWasmInitialized) {
41047 throw new Error("initializeWasm() must be awaited first!");
41049 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
41050 // debug statements here
41052 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41054 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
41055 if(!isWasmInitialized) {
41056 throw new Error("initializeWasm() must be awaited first!");
41058 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
41059 return nativeResponseValue;
41061 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
41063 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
41064 if(!isWasmInitialized) {
41065 throw new Error("initializeWasm() must be awaited first!");
41067 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
41068 // debug statements here
41070 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
41072 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
41073 if(!isWasmInitialized) {
41074 throw new Error("initializeWasm() must be awaited first!");
41076 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
41077 return nativeResponseValue;
41079 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
41081 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
41082 if(!isWasmInitialized) {
41083 throw new Error("initializeWasm() must be awaited first!");
41085 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
41086 // debug statements here
41088 // struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41090 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
41091 if(!isWasmInitialized) {
41092 throw new Error("initializeWasm() must be awaited first!");
41094 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
41095 return nativeResponseValue;
41097 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
41099 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
41100 if(!isWasmInitialized) {
41101 throw new Error("initializeWasm() must be awaited first!");
41103 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
41104 // debug statements here
41106 // struct LDKCVec_SocketAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41108 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
41109 if(!isWasmInitialized) {
41110 throw new Error("initializeWasm() must be awaited first!");
41112 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
41113 return nativeResponseValue;
41115 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_SocketAddressZ val);
41117 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
41118 if(!isWasmInitialized) {
41119 throw new Error("initializeWasm() must be awaited first!");
41121 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
41122 // debug statements here
41124 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_get_excess_address_data(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41126 export function UnsignedNodeAnnouncement_get_excess_address_data(this_ptr: bigint): number {
41127 if(!isWasmInitialized) {
41128 throw new Error("initializeWasm() must be awaited first!");
41130 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_excess_address_data(this_ptr);
41131 return nativeResponseValue;
41133 // void UnsignedNodeAnnouncement_set_excess_address_data(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41135 export function UnsignedNodeAnnouncement_set_excess_address_data(this_ptr: bigint, val: number): void {
41136 if(!isWasmInitialized) {
41137 throw new Error("initializeWasm() must be awaited first!");
41139 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_excess_address_data(this_ptr, val);
41140 // debug statements here
41142 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_get_excess_data(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
41144 export function UnsignedNodeAnnouncement_get_excess_data(this_ptr: bigint): number {
41145 if(!isWasmInitialized) {
41146 throw new Error("initializeWasm() must be awaited first!");
41148 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_excess_data(this_ptr);
41149 return nativeResponseValue;
41151 // void UnsignedNodeAnnouncement_set_excess_data(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41153 export function UnsignedNodeAnnouncement_set_excess_data(this_ptr: bigint, val: number): void {
41154 if(!isWasmInitialized) {
41155 throw new Error("initializeWasm() must be awaited first!");
41157 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_excess_data(this_ptr, val);
41158 // debug statements here
41160 // MUST_USE_RES struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_new(struct LDKNodeFeatures features_arg, uint32_t timestamp_arg, struct LDKNodeId node_id_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_SocketAddressZ addresses_arg, struct LDKCVec_u8Z excess_address_data_arg, struct LDKCVec_u8Z excess_data_arg);
41162 export function UnsignedNodeAnnouncement_new(features_arg: bigint, timestamp_arg: number, node_id_arg: bigint, rgb_arg: number, alias_arg: bigint, addresses_arg: number, excess_address_data_arg: number, excess_data_arg: number): bigint {
41163 if(!isWasmInitialized) {
41164 throw new Error("initializeWasm() must be awaited first!");
41166 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_new(features_arg, timestamp_arg, node_id_arg, rgb_arg, alias_arg, addresses_arg, excess_address_data_arg, excess_data_arg);
41167 return nativeResponseValue;
41169 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
41171 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
41172 if(!isWasmInitialized) {
41173 throw new Error("initializeWasm() must be awaited first!");
41175 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
41176 return nativeResponseValue;
41178 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
41180 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
41181 if(!isWasmInitialized) {
41182 throw new Error("initializeWasm() must be awaited first!");
41184 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
41185 return nativeResponseValue;
41187 // uint64_t UnsignedNodeAnnouncement_hash(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR o);
41189 export function UnsignedNodeAnnouncement_hash(o: bigint): bigint {
41190 if(!isWasmInitialized) {
41191 throw new Error("initializeWasm() must be awaited first!");
41193 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_hash(o);
41194 return nativeResponseValue;
41196 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
41198 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
41199 if(!isWasmInitialized) {
41200 throw new Error("initializeWasm() must be awaited first!");
41202 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
41203 return nativeResponseValue;
41205 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
41207 export function NodeAnnouncement_free(this_obj: bigint): void {
41208 if(!isWasmInitialized) {
41209 throw new Error("initializeWasm() must be awaited first!");
41211 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
41212 // debug statements here
41214 // struct LDKECDSASignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
41216 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
41217 if(!isWasmInitialized) {
41218 throw new Error("initializeWasm() must be awaited first!");
41220 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
41221 return nativeResponseValue;
41223 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41225 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
41226 if(!isWasmInitialized) {
41227 throw new Error("initializeWasm() must be awaited first!");
41229 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
41230 // debug statements here
41232 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
41234 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
41235 if(!isWasmInitialized) {
41236 throw new Error("initializeWasm() must be awaited first!");
41238 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
41239 return nativeResponseValue;
41241 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
41243 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
41244 if(!isWasmInitialized) {
41245 throw new Error("initializeWasm() must be awaited first!");
41247 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
41248 // debug statements here
41250 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
41252 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
41253 if(!isWasmInitialized) {
41254 throw new Error("initializeWasm() must be awaited first!");
41256 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
41257 return nativeResponseValue;
41259 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
41261 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
41262 if(!isWasmInitialized) {
41263 throw new Error("initializeWasm() must be awaited first!");
41265 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
41266 return nativeResponseValue;
41268 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
41270 export function NodeAnnouncement_clone(orig: bigint): bigint {
41271 if(!isWasmInitialized) {
41272 throw new Error("initializeWasm() must be awaited first!");
41274 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
41275 return nativeResponseValue;
41277 // uint64_t NodeAnnouncement_hash(const struct LDKNodeAnnouncement *NONNULL_PTR o);
41279 export function NodeAnnouncement_hash(o: bigint): bigint {
41280 if(!isWasmInitialized) {
41281 throw new Error("initializeWasm() must be awaited first!");
41283 const nativeResponseValue = wasm.TS_NodeAnnouncement_hash(o);
41284 return nativeResponseValue;
41286 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
41288 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
41289 if(!isWasmInitialized) {
41290 throw new Error("initializeWasm() must be awaited first!");
41292 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
41293 return nativeResponseValue;
41295 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
41297 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
41298 if(!isWasmInitialized) {
41299 throw new Error("initializeWasm() must be awaited first!");
41301 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
41302 // debug statements here
41304 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41306 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
41307 if(!isWasmInitialized) {
41308 throw new Error("initializeWasm() must be awaited first!");
41310 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
41311 return nativeResponseValue;
41313 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
41315 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
41316 if(!isWasmInitialized) {
41317 throw new Error("initializeWasm() must be awaited first!");
41319 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
41320 // debug statements here
41322 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
41324 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
41325 if(!isWasmInitialized) {
41326 throw new Error("initializeWasm() must be awaited first!");
41328 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
41329 return nativeResponseValue;
41331 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
41333 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
41334 if(!isWasmInitialized) {
41335 throw new Error("initializeWasm() must be awaited first!");
41337 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
41338 // debug statements here
41340 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41342 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
41343 if(!isWasmInitialized) {
41344 throw new Error("initializeWasm() must be awaited first!");
41346 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
41347 return nativeResponseValue;
41349 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
41351 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
41352 if(!isWasmInitialized) {
41353 throw new Error("initializeWasm() must be awaited first!");
41355 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
41356 // debug statements here
41358 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41360 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
41361 if(!isWasmInitialized) {
41362 throw new Error("initializeWasm() must be awaited first!");
41364 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
41365 return nativeResponseValue;
41367 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
41369 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
41370 if(!isWasmInitialized) {
41371 throw new Error("initializeWasm() must be awaited first!");
41373 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
41374 // debug statements here
41376 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41378 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
41379 if(!isWasmInitialized) {
41380 throw new Error("initializeWasm() must be awaited first!");
41382 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
41383 return nativeResponseValue;
41385 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
41387 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
41388 if(!isWasmInitialized) {
41389 throw new Error("initializeWasm() must be awaited first!");
41391 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
41392 // debug statements here
41394 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41396 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
41397 if(!isWasmInitialized) {
41398 throw new Error("initializeWasm() must be awaited first!");
41400 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
41401 return nativeResponseValue;
41403 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
41405 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
41406 if(!isWasmInitialized) {
41407 throw new Error("initializeWasm() must be awaited first!");
41409 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
41410 // debug statements here
41412 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41414 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
41415 if(!isWasmInitialized) {
41416 throw new Error("initializeWasm() must be awaited first!");
41418 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
41419 return nativeResponseValue;
41421 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
41423 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
41424 if(!isWasmInitialized) {
41425 throw new Error("initializeWasm() must be awaited first!");
41427 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
41428 // debug statements here
41430 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_get_excess_data(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
41432 export function UnsignedChannelAnnouncement_get_excess_data(this_ptr: bigint): number {
41433 if(!isWasmInitialized) {
41434 throw new Error("initializeWasm() must be awaited first!");
41436 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_excess_data(this_ptr);
41437 return nativeResponseValue;
41439 // void UnsignedChannelAnnouncement_set_excess_data(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41441 export function UnsignedChannelAnnouncement_set_excess_data(this_ptr: bigint, val: number): void {
41442 if(!isWasmInitialized) {
41443 throw new Error("initializeWasm() must be awaited first!");
41445 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_excess_data(this_ptr, val);
41446 // debug statements here
41448 // MUST_USE_RES struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_new(struct LDKChannelFeatures features_arg, struct LDKThirtyTwoBytes chain_hash_arg, uint64_t short_channel_id_arg, struct LDKNodeId node_id_1_arg, struct LDKNodeId node_id_2_arg, struct LDKNodeId bitcoin_key_1_arg, struct LDKNodeId bitcoin_key_2_arg, struct LDKCVec_u8Z excess_data_arg);
41450 export function UnsignedChannelAnnouncement_new(features_arg: bigint, chain_hash_arg: number, short_channel_id_arg: bigint, node_id_1_arg: bigint, node_id_2_arg: bigint, bitcoin_key_1_arg: bigint, bitcoin_key_2_arg: bigint, excess_data_arg: number): bigint {
41451 if(!isWasmInitialized) {
41452 throw new Error("initializeWasm() must be awaited first!");
41454 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_new(features_arg, chain_hash_arg, short_channel_id_arg, node_id_1_arg, node_id_2_arg, bitcoin_key_1_arg, bitcoin_key_2_arg, excess_data_arg);
41455 return nativeResponseValue;
41457 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
41459 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
41460 if(!isWasmInitialized) {
41461 throw new Error("initializeWasm() must be awaited first!");
41463 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
41464 return nativeResponseValue;
41466 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
41468 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
41469 if(!isWasmInitialized) {
41470 throw new Error("initializeWasm() must be awaited first!");
41472 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
41473 return nativeResponseValue;
41475 // uint64_t UnsignedChannelAnnouncement_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR o);
41477 export function UnsignedChannelAnnouncement_hash(o: bigint): bigint {
41478 if(!isWasmInitialized) {
41479 throw new Error("initializeWasm() must be awaited first!");
41481 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_hash(o);
41482 return nativeResponseValue;
41484 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
41486 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
41487 if(!isWasmInitialized) {
41488 throw new Error("initializeWasm() must be awaited first!");
41490 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
41491 return nativeResponseValue;
41493 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
41495 export function ChannelAnnouncement_free(this_obj: bigint): void {
41496 if(!isWasmInitialized) {
41497 throw new Error("initializeWasm() must be awaited first!");
41499 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
41500 // debug statements here
41502 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
41504 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
41505 if(!isWasmInitialized) {
41506 throw new Error("initializeWasm() must be awaited first!");
41508 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
41509 return nativeResponseValue;
41511 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41513 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
41514 if(!isWasmInitialized) {
41515 throw new Error("initializeWasm() must be awaited first!");
41517 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
41518 // debug statements here
41520 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
41522 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
41523 if(!isWasmInitialized) {
41524 throw new Error("initializeWasm() must be awaited first!");
41526 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
41527 return nativeResponseValue;
41529 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41531 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
41532 if(!isWasmInitialized) {
41533 throw new Error("initializeWasm() must be awaited first!");
41535 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
41536 // debug statements here
41538 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
41540 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
41541 if(!isWasmInitialized) {
41542 throw new Error("initializeWasm() must be awaited first!");
41544 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
41545 return nativeResponseValue;
41547 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41549 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
41550 if(!isWasmInitialized) {
41551 throw new Error("initializeWasm() must be awaited first!");
41553 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
41554 // debug statements here
41556 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
41558 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
41559 if(!isWasmInitialized) {
41560 throw new Error("initializeWasm() must be awaited first!");
41562 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
41563 return nativeResponseValue;
41565 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41567 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
41568 if(!isWasmInitialized) {
41569 throw new Error("initializeWasm() must be awaited first!");
41571 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
41572 // debug statements here
41574 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
41576 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
41577 if(!isWasmInitialized) {
41578 throw new Error("initializeWasm() must be awaited first!");
41580 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
41581 return nativeResponseValue;
41583 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
41585 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
41586 if(!isWasmInitialized) {
41587 throw new Error("initializeWasm() must be awaited first!");
41589 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
41590 // debug statements here
41592 // MUST_USE_RES struct LDKChannelAnnouncement ChannelAnnouncement_new(struct LDKECDSASignature node_signature_1_arg, struct LDKECDSASignature node_signature_2_arg, struct LDKECDSASignature bitcoin_signature_1_arg, struct LDKECDSASignature bitcoin_signature_2_arg, struct LDKUnsignedChannelAnnouncement contents_arg);
41594 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 {
41595 if(!isWasmInitialized) {
41596 throw new Error("initializeWasm() must be awaited first!");
41598 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
41599 return nativeResponseValue;
41601 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
41603 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
41604 if(!isWasmInitialized) {
41605 throw new Error("initializeWasm() must be awaited first!");
41607 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
41608 return nativeResponseValue;
41610 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
41612 export function ChannelAnnouncement_clone(orig: bigint): bigint {
41613 if(!isWasmInitialized) {
41614 throw new Error("initializeWasm() must be awaited first!");
41616 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
41617 return nativeResponseValue;
41619 // uint64_t ChannelAnnouncement_hash(const struct LDKChannelAnnouncement *NONNULL_PTR o);
41621 export function ChannelAnnouncement_hash(o: bigint): bigint {
41622 if(!isWasmInitialized) {
41623 throw new Error("initializeWasm() must be awaited first!");
41625 const nativeResponseValue = wasm.TS_ChannelAnnouncement_hash(o);
41626 return nativeResponseValue;
41628 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
41630 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
41631 if(!isWasmInitialized) {
41632 throw new Error("initializeWasm() must be awaited first!");
41634 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
41635 return nativeResponseValue;
41637 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
41639 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
41640 if(!isWasmInitialized) {
41641 throw new Error("initializeWasm() must be awaited first!");
41643 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
41644 // debug statements here
41646 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
41648 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
41649 if(!isWasmInitialized) {
41650 throw new Error("initializeWasm() must be awaited first!");
41652 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
41653 return nativeResponseValue;
41655 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
41657 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
41658 if(!isWasmInitialized) {
41659 throw new Error("initializeWasm() must be awaited first!");
41661 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
41662 // debug statements here
41664 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41666 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
41667 if(!isWasmInitialized) {
41668 throw new Error("initializeWasm() must be awaited first!");
41670 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
41671 return nativeResponseValue;
41673 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
41675 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
41676 if(!isWasmInitialized) {
41677 throw new Error("initializeWasm() must be awaited first!");
41679 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
41680 // debug statements here
41682 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41684 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
41685 if(!isWasmInitialized) {
41686 throw new Error("initializeWasm() must be awaited first!");
41688 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
41689 return nativeResponseValue;
41691 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
41693 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
41694 if(!isWasmInitialized) {
41695 throw new Error("initializeWasm() must be awaited first!");
41697 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
41698 // debug statements here
41700 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41702 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
41703 if(!isWasmInitialized) {
41704 throw new Error("initializeWasm() must be awaited first!");
41706 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
41707 return nativeResponseValue;
41709 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
41711 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
41712 if(!isWasmInitialized) {
41713 throw new Error("initializeWasm() must be awaited first!");
41715 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
41716 // debug statements here
41718 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41720 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
41721 if(!isWasmInitialized) {
41722 throw new Error("initializeWasm() must be awaited first!");
41724 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
41725 return nativeResponseValue;
41727 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
41729 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
41730 if(!isWasmInitialized) {
41731 throw new Error("initializeWasm() must be awaited first!");
41733 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
41734 // debug statements here
41736 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41738 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
41739 if(!isWasmInitialized) {
41740 throw new Error("initializeWasm() must be awaited first!");
41742 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
41743 return nativeResponseValue;
41745 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
41747 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
41748 if(!isWasmInitialized) {
41749 throw new Error("initializeWasm() must be awaited first!");
41751 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
41752 // debug statements here
41754 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41756 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
41757 if(!isWasmInitialized) {
41758 throw new Error("initializeWasm() must be awaited first!");
41760 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
41761 return nativeResponseValue;
41763 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
41765 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
41766 if(!isWasmInitialized) {
41767 throw new Error("initializeWasm() must be awaited first!");
41769 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
41770 // debug statements here
41772 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41774 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
41775 if(!isWasmInitialized) {
41776 throw new Error("initializeWasm() must be awaited first!");
41778 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
41779 return nativeResponseValue;
41781 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
41783 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
41784 if(!isWasmInitialized) {
41785 throw new Error("initializeWasm() must be awaited first!");
41787 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
41788 // debug statements here
41790 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41792 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
41793 if(!isWasmInitialized) {
41794 throw new Error("initializeWasm() must be awaited first!");
41796 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
41797 return nativeResponseValue;
41799 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
41801 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
41802 if(!isWasmInitialized) {
41803 throw new Error("initializeWasm() must be awaited first!");
41805 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
41806 // debug statements here
41808 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
41810 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
41811 if(!isWasmInitialized) {
41812 throw new Error("initializeWasm() must be awaited first!");
41814 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
41815 return nativeResponseValue;
41817 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41819 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
41820 if(!isWasmInitialized) {
41821 throw new Error("initializeWasm() must be awaited first!");
41823 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
41824 // debug statements here
41826 // 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);
41828 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 {
41829 if(!isWasmInitialized) {
41830 throw new Error("initializeWasm() must be awaited first!");
41832 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);
41833 return nativeResponseValue;
41835 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
41837 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
41838 if(!isWasmInitialized) {
41839 throw new Error("initializeWasm() must be awaited first!");
41841 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
41842 return nativeResponseValue;
41844 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
41846 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
41847 if(!isWasmInitialized) {
41848 throw new Error("initializeWasm() must be awaited first!");
41850 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
41851 return nativeResponseValue;
41853 // uint64_t UnsignedChannelUpdate_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR o);
41855 export function UnsignedChannelUpdate_hash(o: bigint): bigint {
41856 if(!isWasmInitialized) {
41857 throw new Error("initializeWasm() must be awaited first!");
41859 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_hash(o);
41860 return nativeResponseValue;
41862 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
41864 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
41865 if(!isWasmInitialized) {
41866 throw new Error("initializeWasm() must be awaited first!");
41868 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
41869 return nativeResponseValue;
41871 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
41873 export function ChannelUpdate_free(this_obj: bigint): void {
41874 if(!isWasmInitialized) {
41875 throw new Error("initializeWasm() must be awaited first!");
41877 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
41878 // debug statements here
41880 // struct LDKECDSASignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
41882 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
41883 if(!isWasmInitialized) {
41884 throw new Error("initializeWasm() must be awaited first!");
41886 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
41887 return nativeResponseValue;
41889 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
41891 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
41892 if(!isWasmInitialized) {
41893 throw new Error("initializeWasm() must be awaited first!");
41895 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
41896 // debug statements here
41898 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
41900 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
41901 if(!isWasmInitialized) {
41902 throw new Error("initializeWasm() must be awaited first!");
41904 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
41905 return nativeResponseValue;
41907 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
41909 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
41910 if(!isWasmInitialized) {
41911 throw new Error("initializeWasm() must be awaited first!");
41913 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
41914 // debug statements here
41916 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
41918 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
41919 if(!isWasmInitialized) {
41920 throw new Error("initializeWasm() must be awaited first!");
41922 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
41923 return nativeResponseValue;
41925 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
41927 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
41928 if(!isWasmInitialized) {
41929 throw new Error("initializeWasm() must be awaited first!");
41931 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
41932 return nativeResponseValue;
41934 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
41936 export function ChannelUpdate_clone(orig: bigint): bigint {
41937 if(!isWasmInitialized) {
41938 throw new Error("initializeWasm() must be awaited first!");
41940 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
41941 return nativeResponseValue;
41943 // uint64_t ChannelUpdate_hash(const struct LDKChannelUpdate *NONNULL_PTR o);
41945 export function ChannelUpdate_hash(o: bigint): bigint {
41946 if(!isWasmInitialized) {
41947 throw new Error("initializeWasm() must be awaited first!");
41949 const nativeResponseValue = wasm.TS_ChannelUpdate_hash(o);
41950 return nativeResponseValue;
41952 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
41954 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
41955 if(!isWasmInitialized) {
41956 throw new Error("initializeWasm() must be awaited first!");
41958 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
41959 return nativeResponseValue;
41961 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
41963 export function QueryChannelRange_free(this_obj: bigint): void {
41964 if(!isWasmInitialized) {
41965 throw new Error("initializeWasm() must be awaited first!");
41967 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
41968 // debug statements here
41970 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
41972 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
41973 if(!isWasmInitialized) {
41974 throw new Error("initializeWasm() must be awaited first!");
41976 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
41977 return nativeResponseValue;
41979 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
41981 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
41982 if(!isWasmInitialized) {
41983 throw new Error("initializeWasm() must be awaited first!");
41985 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
41986 // debug statements here
41988 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
41990 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
41991 if(!isWasmInitialized) {
41992 throw new Error("initializeWasm() must be awaited first!");
41994 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
41995 return nativeResponseValue;
41997 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
41999 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
42000 if(!isWasmInitialized) {
42001 throw new Error("initializeWasm() must be awaited first!");
42003 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
42004 // debug statements here
42006 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
42008 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
42009 if(!isWasmInitialized) {
42010 throw new Error("initializeWasm() must be awaited first!");
42012 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
42013 return nativeResponseValue;
42015 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
42017 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
42018 if(!isWasmInitialized) {
42019 throw new Error("initializeWasm() must be awaited first!");
42021 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
42022 // debug statements here
42024 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
42026 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
42027 if(!isWasmInitialized) {
42028 throw new Error("initializeWasm() must be awaited first!");
42030 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
42031 return nativeResponseValue;
42033 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
42035 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
42036 if(!isWasmInitialized) {
42037 throw new Error("initializeWasm() must be awaited first!");
42039 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
42040 return nativeResponseValue;
42042 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
42044 export function QueryChannelRange_clone(orig: bigint): bigint {
42045 if(!isWasmInitialized) {
42046 throw new Error("initializeWasm() must be awaited first!");
42048 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
42049 return nativeResponseValue;
42051 // uint64_t QueryChannelRange_hash(const struct LDKQueryChannelRange *NONNULL_PTR o);
42053 export function QueryChannelRange_hash(o: bigint): bigint {
42054 if(!isWasmInitialized) {
42055 throw new Error("initializeWasm() must be awaited first!");
42057 const nativeResponseValue = wasm.TS_QueryChannelRange_hash(o);
42058 return nativeResponseValue;
42060 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
42062 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
42063 if(!isWasmInitialized) {
42064 throw new Error("initializeWasm() must be awaited first!");
42066 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
42067 return nativeResponseValue;
42069 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
42071 export function ReplyChannelRange_free(this_obj: bigint): void {
42072 if(!isWasmInitialized) {
42073 throw new Error("initializeWasm() must be awaited first!");
42075 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
42076 // debug statements here
42078 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
42080 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
42081 if(!isWasmInitialized) {
42082 throw new Error("initializeWasm() must be awaited first!");
42084 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
42085 return nativeResponseValue;
42087 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42089 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
42090 if(!isWasmInitialized) {
42091 throw new Error("initializeWasm() must be awaited first!");
42093 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
42094 // debug statements here
42096 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
42098 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
42099 if(!isWasmInitialized) {
42100 throw new Error("initializeWasm() must be awaited first!");
42102 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
42103 return nativeResponseValue;
42105 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
42107 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
42108 if(!isWasmInitialized) {
42109 throw new Error("initializeWasm() must be awaited first!");
42111 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
42112 // debug statements here
42114 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
42116 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
42117 if(!isWasmInitialized) {
42118 throw new Error("initializeWasm() must be awaited first!");
42120 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
42121 return nativeResponseValue;
42123 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
42125 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
42126 if(!isWasmInitialized) {
42127 throw new Error("initializeWasm() must be awaited first!");
42129 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
42130 // debug statements here
42132 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
42134 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
42135 if(!isWasmInitialized) {
42136 throw new Error("initializeWasm() must be awaited first!");
42138 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
42139 return nativeResponseValue;
42141 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
42143 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
42144 if(!isWasmInitialized) {
42145 throw new Error("initializeWasm() must be awaited first!");
42147 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
42148 // debug statements here
42150 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
42152 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
42153 if(!isWasmInitialized) {
42154 throw new Error("initializeWasm() must be awaited first!");
42156 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
42157 return nativeResponseValue;
42159 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
42161 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
42162 if(!isWasmInitialized) {
42163 throw new Error("initializeWasm() must be awaited first!");
42165 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
42166 // debug statements here
42168 // 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);
42170 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 {
42171 if(!isWasmInitialized) {
42172 throw new Error("initializeWasm() must be awaited first!");
42174 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
42175 return nativeResponseValue;
42177 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
42179 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
42180 if(!isWasmInitialized) {
42181 throw new Error("initializeWasm() must be awaited first!");
42183 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
42184 return nativeResponseValue;
42186 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
42188 export function ReplyChannelRange_clone(orig: bigint): bigint {
42189 if(!isWasmInitialized) {
42190 throw new Error("initializeWasm() must be awaited first!");
42192 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
42193 return nativeResponseValue;
42195 // uint64_t ReplyChannelRange_hash(const struct LDKReplyChannelRange *NONNULL_PTR o);
42197 export function ReplyChannelRange_hash(o: bigint): bigint {
42198 if(!isWasmInitialized) {
42199 throw new Error("initializeWasm() must be awaited first!");
42201 const nativeResponseValue = wasm.TS_ReplyChannelRange_hash(o);
42202 return nativeResponseValue;
42204 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
42206 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
42207 if(!isWasmInitialized) {
42208 throw new Error("initializeWasm() must be awaited first!");
42210 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
42211 return nativeResponseValue;
42213 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
42215 export function QueryShortChannelIds_free(this_obj: bigint): void {
42216 if(!isWasmInitialized) {
42217 throw new Error("initializeWasm() must be awaited first!");
42219 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
42220 // debug statements here
42222 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
42224 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
42225 if(!isWasmInitialized) {
42226 throw new Error("initializeWasm() must be awaited first!");
42228 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
42229 return nativeResponseValue;
42231 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42233 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
42234 if(!isWasmInitialized) {
42235 throw new Error("initializeWasm() must be awaited first!");
42237 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
42238 // debug statements here
42240 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
42242 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
42243 if(!isWasmInitialized) {
42244 throw new Error("initializeWasm() must be awaited first!");
42246 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
42247 return nativeResponseValue;
42249 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
42251 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
42252 if(!isWasmInitialized) {
42253 throw new Error("initializeWasm() must be awaited first!");
42255 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
42256 // debug statements here
42258 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
42260 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
42261 if(!isWasmInitialized) {
42262 throw new Error("initializeWasm() must be awaited first!");
42264 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
42265 return nativeResponseValue;
42267 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
42269 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
42270 if(!isWasmInitialized) {
42271 throw new Error("initializeWasm() must be awaited first!");
42273 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
42274 return nativeResponseValue;
42276 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
42278 export function QueryShortChannelIds_clone(orig: bigint): bigint {
42279 if(!isWasmInitialized) {
42280 throw new Error("initializeWasm() must be awaited first!");
42282 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
42283 return nativeResponseValue;
42285 // uint64_t QueryShortChannelIds_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR o);
42287 export function QueryShortChannelIds_hash(o: bigint): bigint {
42288 if(!isWasmInitialized) {
42289 throw new Error("initializeWasm() must be awaited first!");
42291 const nativeResponseValue = wasm.TS_QueryShortChannelIds_hash(o);
42292 return nativeResponseValue;
42294 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
42296 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
42297 if(!isWasmInitialized) {
42298 throw new Error("initializeWasm() must be awaited first!");
42300 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
42301 return nativeResponseValue;
42303 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
42305 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
42306 if(!isWasmInitialized) {
42307 throw new Error("initializeWasm() must be awaited first!");
42309 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
42310 // debug statements here
42312 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
42314 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
42315 if(!isWasmInitialized) {
42316 throw new Error("initializeWasm() must be awaited first!");
42318 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
42319 return nativeResponseValue;
42321 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42323 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
42324 if(!isWasmInitialized) {
42325 throw new Error("initializeWasm() must be awaited first!");
42327 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
42328 // debug statements here
42330 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
42332 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
42333 if(!isWasmInitialized) {
42334 throw new Error("initializeWasm() must be awaited first!");
42336 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
42337 return nativeResponseValue;
42339 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
42341 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
42342 if(!isWasmInitialized) {
42343 throw new Error("initializeWasm() must be awaited first!");
42345 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
42346 // debug statements here
42348 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
42350 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
42351 if(!isWasmInitialized) {
42352 throw new Error("initializeWasm() must be awaited first!");
42354 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
42355 return nativeResponseValue;
42357 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
42359 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
42360 if(!isWasmInitialized) {
42361 throw new Error("initializeWasm() must be awaited first!");
42363 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
42364 return nativeResponseValue;
42366 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
42368 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
42369 if(!isWasmInitialized) {
42370 throw new Error("initializeWasm() must be awaited first!");
42372 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
42373 return nativeResponseValue;
42375 // uint64_t ReplyShortChannelIdsEnd_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR o);
42377 export function ReplyShortChannelIdsEnd_hash(o: bigint): bigint {
42378 if(!isWasmInitialized) {
42379 throw new Error("initializeWasm() must be awaited first!");
42381 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_hash(o);
42382 return nativeResponseValue;
42384 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
42386 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
42387 if(!isWasmInitialized) {
42388 throw new Error("initializeWasm() must be awaited first!");
42390 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
42391 return nativeResponseValue;
42393 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
42395 export function GossipTimestampFilter_free(this_obj: bigint): void {
42396 if(!isWasmInitialized) {
42397 throw new Error("initializeWasm() must be awaited first!");
42399 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
42400 // debug statements here
42402 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
42404 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
42405 if(!isWasmInitialized) {
42406 throw new Error("initializeWasm() must be awaited first!");
42408 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
42409 return nativeResponseValue;
42411 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42413 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
42414 if(!isWasmInitialized) {
42415 throw new Error("initializeWasm() must be awaited first!");
42417 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
42418 // debug statements here
42420 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
42422 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
42423 if(!isWasmInitialized) {
42424 throw new Error("initializeWasm() must be awaited first!");
42426 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
42427 return nativeResponseValue;
42429 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
42431 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
42432 if(!isWasmInitialized) {
42433 throw new Error("initializeWasm() must be awaited first!");
42435 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
42436 // debug statements here
42438 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
42440 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
42441 if(!isWasmInitialized) {
42442 throw new Error("initializeWasm() must be awaited first!");
42444 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
42445 return nativeResponseValue;
42447 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
42449 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
42450 if(!isWasmInitialized) {
42451 throw new Error("initializeWasm() must be awaited first!");
42453 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
42454 // debug statements here
42456 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
42458 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
42459 if(!isWasmInitialized) {
42460 throw new Error("initializeWasm() must be awaited first!");
42462 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
42463 return nativeResponseValue;
42465 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
42467 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
42468 if(!isWasmInitialized) {
42469 throw new Error("initializeWasm() must be awaited first!");
42471 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
42472 return nativeResponseValue;
42474 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
42476 export function GossipTimestampFilter_clone(orig: bigint): bigint {
42477 if(!isWasmInitialized) {
42478 throw new Error("initializeWasm() must be awaited first!");
42480 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
42481 return nativeResponseValue;
42483 // uint64_t GossipTimestampFilter_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR o);
42485 export function GossipTimestampFilter_hash(o: bigint): bigint {
42486 if(!isWasmInitialized) {
42487 throw new Error("initializeWasm() must be awaited first!");
42489 const nativeResponseValue = wasm.TS_GossipTimestampFilter_hash(o);
42490 return nativeResponseValue;
42492 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
42494 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
42495 if(!isWasmInitialized) {
42496 throw new Error("initializeWasm() must be awaited first!");
42498 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
42499 return nativeResponseValue;
42501 // void ErrorAction_free(struct LDKErrorAction this_ptr);
42503 export function ErrorAction_free(this_ptr: bigint): void {
42504 if(!isWasmInitialized) {
42505 throw new Error("initializeWasm() must be awaited first!");
42507 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
42508 // debug statements here
42510 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
42512 export function ErrorAction_clone_ptr(arg: bigint): bigint {
42513 if(!isWasmInitialized) {
42514 throw new Error("initializeWasm() must be awaited first!");
42516 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
42517 return nativeResponseValue;
42519 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
42521 export function ErrorAction_clone(orig: bigint): bigint {
42522 if(!isWasmInitialized) {
42523 throw new Error("initializeWasm() must be awaited first!");
42525 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
42526 return nativeResponseValue;
42528 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
42530 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
42531 if(!isWasmInitialized) {
42532 throw new Error("initializeWasm() must be awaited first!");
42534 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
42535 return nativeResponseValue;
42537 // struct LDKErrorAction ErrorAction_disconnect_peer_with_warning(struct LDKWarningMessage msg);
42539 export function ErrorAction_disconnect_peer_with_warning(msg: bigint): bigint {
42540 if(!isWasmInitialized) {
42541 throw new Error("initializeWasm() must be awaited first!");
42543 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer_with_warning(msg);
42544 return nativeResponseValue;
42546 // struct LDKErrorAction ErrorAction_ignore_error(void);
42548 export function ErrorAction_ignore_error(): bigint {
42549 if(!isWasmInitialized) {
42550 throw new Error("initializeWasm() must be awaited first!");
42552 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
42553 return nativeResponseValue;
42555 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
42557 export function ErrorAction_ignore_and_log(a: Level): bigint {
42558 if(!isWasmInitialized) {
42559 throw new Error("initializeWasm() must be awaited first!");
42561 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
42562 return nativeResponseValue;
42564 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
42566 export function ErrorAction_ignore_duplicate_gossip(): bigint {
42567 if(!isWasmInitialized) {
42568 throw new Error("initializeWasm() must be awaited first!");
42570 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
42571 return nativeResponseValue;
42573 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
42575 export function ErrorAction_send_error_message(msg: bigint): bigint {
42576 if(!isWasmInitialized) {
42577 throw new Error("initializeWasm() must be awaited first!");
42579 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
42580 return nativeResponseValue;
42582 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
42584 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
42585 if(!isWasmInitialized) {
42586 throw new Error("initializeWasm() must be awaited first!");
42588 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
42589 return nativeResponseValue;
42591 // uint64_t ErrorAction_hash(const struct LDKErrorAction *NONNULL_PTR o);
42593 export function ErrorAction_hash(o: bigint): bigint {
42594 if(!isWasmInitialized) {
42595 throw new Error("initializeWasm() must be awaited first!");
42597 const nativeResponseValue = wasm.TS_ErrorAction_hash(o);
42598 return nativeResponseValue;
42600 // void LightningError_free(struct LDKLightningError this_obj);
42602 export function LightningError_free(this_obj: bigint): void {
42603 if(!isWasmInitialized) {
42604 throw new Error("initializeWasm() must be awaited first!");
42606 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
42607 // debug statements here
42609 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
42611 export function LightningError_get_err(this_ptr: bigint): number {
42612 if(!isWasmInitialized) {
42613 throw new Error("initializeWasm() must be awaited first!");
42615 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
42616 return nativeResponseValue;
42618 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
42620 export function LightningError_set_err(this_ptr: bigint, val: number): void {
42621 if(!isWasmInitialized) {
42622 throw new Error("initializeWasm() must be awaited first!");
42624 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
42625 // debug statements here
42627 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
42629 export function LightningError_get_action(this_ptr: bigint): bigint {
42630 if(!isWasmInitialized) {
42631 throw new Error("initializeWasm() must be awaited first!");
42633 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
42634 return nativeResponseValue;
42636 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
42638 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
42639 if(!isWasmInitialized) {
42640 throw new Error("initializeWasm() must be awaited first!");
42642 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
42643 // debug statements here
42645 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
42647 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
42648 if(!isWasmInitialized) {
42649 throw new Error("initializeWasm() must be awaited first!");
42651 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
42652 return nativeResponseValue;
42654 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
42656 export function LightningError_clone_ptr(arg: bigint): bigint {
42657 if(!isWasmInitialized) {
42658 throw new Error("initializeWasm() must be awaited first!");
42660 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
42661 return nativeResponseValue;
42663 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
42665 export function LightningError_clone(orig: bigint): bigint {
42666 if(!isWasmInitialized) {
42667 throw new Error("initializeWasm() must be awaited first!");
42669 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
42670 return nativeResponseValue;
42672 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
42674 export function CommitmentUpdate_free(this_obj: bigint): void {
42675 if(!isWasmInitialized) {
42676 throw new Error("initializeWasm() must be awaited first!");
42678 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
42679 // debug statements here
42681 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42683 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
42684 if(!isWasmInitialized) {
42685 throw new Error("initializeWasm() must be awaited first!");
42687 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
42688 return nativeResponseValue;
42690 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
42692 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
42693 if(!isWasmInitialized) {
42694 throw new Error("initializeWasm() must be awaited first!");
42696 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
42697 // debug statements here
42699 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42701 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
42702 if(!isWasmInitialized) {
42703 throw new Error("initializeWasm() must be awaited first!");
42705 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
42706 return nativeResponseValue;
42708 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
42710 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
42711 if(!isWasmInitialized) {
42712 throw new Error("initializeWasm() must be awaited first!");
42714 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
42715 // debug statements here
42717 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42719 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
42720 if(!isWasmInitialized) {
42721 throw new Error("initializeWasm() must be awaited first!");
42723 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
42724 return nativeResponseValue;
42726 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
42728 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
42729 if(!isWasmInitialized) {
42730 throw new Error("initializeWasm() must be awaited first!");
42732 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
42733 // debug statements here
42735 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42737 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
42738 if(!isWasmInitialized) {
42739 throw new Error("initializeWasm() must be awaited first!");
42741 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
42742 return nativeResponseValue;
42744 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
42746 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
42747 if(!isWasmInitialized) {
42748 throw new Error("initializeWasm() must be awaited first!");
42750 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
42751 // debug statements here
42753 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42755 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
42756 if(!isWasmInitialized) {
42757 throw new Error("initializeWasm() must be awaited first!");
42759 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
42760 return nativeResponseValue;
42762 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
42764 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
42765 if(!isWasmInitialized) {
42766 throw new Error("initializeWasm() must be awaited first!");
42768 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
42769 // debug statements here
42771 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
42773 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
42774 if(!isWasmInitialized) {
42775 throw new Error("initializeWasm() must be awaited first!");
42777 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
42778 return nativeResponseValue;
42780 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
42782 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
42783 if(!isWasmInitialized) {
42784 throw new Error("initializeWasm() must be awaited first!");
42786 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
42787 // debug statements here
42789 // 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);
42791 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 {
42792 if(!isWasmInitialized) {
42793 throw new Error("initializeWasm() must be awaited first!");
42795 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);
42796 return nativeResponseValue;
42798 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
42800 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
42801 if(!isWasmInitialized) {
42802 throw new Error("initializeWasm() must be awaited first!");
42804 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
42805 return nativeResponseValue;
42807 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
42809 export function CommitmentUpdate_clone(orig: bigint): bigint {
42810 if(!isWasmInitialized) {
42811 throw new Error("initializeWasm() must be awaited first!");
42813 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
42814 return nativeResponseValue;
42816 // uint64_t CommitmentUpdate_hash(const struct LDKCommitmentUpdate *NONNULL_PTR o);
42818 export function CommitmentUpdate_hash(o: bigint): bigint {
42819 if(!isWasmInitialized) {
42820 throw new Error("initializeWasm() must be awaited first!");
42822 const nativeResponseValue = wasm.TS_CommitmentUpdate_hash(o);
42823 return nativeResponseValue;
42825 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
42827 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
42828 if(!isWasmInitialized) {
42829 throw new Error("initializeWasm() must be awaited first!");
42831 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
42832 return nativeResponseValue;
42834 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
42836 export function ChannelMessageHandler_free(this_ptr: bigint): void {
42837 if(!isWasmInitialized) {
42838 throw new Error("initializeWasm() must be awaited first!");
42840 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
42841 // debug statements here
42843 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
42845 export function RoutingMessageHandler_free(this_ptr: bigint): void {
42846 if(!isWasmInitialized) {
42847 throw new Error("initializeWasm() must be awaited first!");
42849 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
42850 // debug statements here
42852 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
42854 export function OnionMessageHandler_free(this_ptr: bigint): void {
42855 if(!isWasmInitialized) {
42856 throw new Error("initializeWasm() must be awaited first!");
42858 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
42859 // debug statements here
42861 // void FinalOnionHopData_free(struct LDKFinalOnionHopData this_obj);
42863 export function FinalOnionHopData_free(this_obj: bigint): void {
42864 if(!isWasmInitialized) {
42865 throw new Error("initializeWasm() must be awaited first!");
42867 const nativeResponseValue = wasm.TS_FinalOnionHopData_free(this_obj);
42868 // debug statements here
42870 // const uint8_t (*FinalOnionHopData_get_payment_secret(const struct LDKFinalOnionHopData *NONNULL_PTR this_ptr))[32];
42872 export function FinalOnionHopData_get_payment_secret(this_ptr: bigint): number {
42873 if(!isWasmInitialized) {
42874 throw new Error("initializeWasm() must be awaited first!");
42876 const nativeResponseValue = wasm.TS_FinalOnionHopData_get_payment_secret(this_ptr);
42877 return nativeResponseValue;
42879 // void FinalOnionHopData_set_payment_secret(struct LDKFinalOnionHopData *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42881 export function FinalOnionHopData_set_payment_secret(this_ptr: bigint, val: number): void {
42882 if(!isWasmInitialized) {
42883 throw new Error("initializeWasm() must be awaited first!");
42885 const nativeResponseValue = wasm.TS_FinalOnionHopData_set_payment_secret(this_ptr, val);
42886 // debug statements here
42888 // uint64_t FinalOnionHopData_get_total_msat(const struct LDKFinalOnionHopData *NONNULL_PTR this_ptr);
42890 export function FinalOnionHopData_get_total_msat(this_ptr: bigint): bigint {
42891 if(!isWasmInitialized) {
42892 throw new Error("initializeWasm() must be awaited first!");
42894 const nativeResponseValue = wasm.TS_FinalOnionHopData_get_total_msat(this_ptr);
42895 return nativeResponseValue;
42897 // void FinalOnionHopData_set_total_msat(struct LDKFinalOnionHopData *NONNULL_PTR this_ptr, uint64_t val);
42899 export function FinalOnionHopData_set_total_msat(this_ptr: bigint, val: bigint): void {
42900 if(!isWasmInitialized) {
42901 throw new Error("initializeWasm() must be awaited first!");
42903 const nativeResponseValue = wasm.TS_FinalOnionHopData_set_total_msat(this_ptr, val);
42904 // debug statements here
42906 // MUST_USE_RES struct LDKFinalOnionHopData FinalOnionHopData_new(struct LDKThirtyTwoBytes payment_secret_arg, uint64_t total_msat_arg);
42908 export function FinalOnionHopData_new(payment_secret_arg: number, total_msat_arg: bigint): bigint {
42909 if(!isWasmInitialized) {
42910 throw new Error("initializeWasm() must be awaited first!");
42912 const nativeResponseValue = wasm.TS_FinalOnionHopData_new(payment_secret_arg, total_msat_arg);
42913 return nativeResponseValue;
42915 // uint64_t FinalOnionHopData_clone_ptr(LDKFinalOnionHopData *NONNULL_PTR arg);
42917 export function FinalOnionHopData_clone_ptr(arg: bigint): bigint {
42918 if(!isWasmInitialized) {
42919 throw new Error("initializeWasm() must be awaited first!");
42921 const nativeResponseValue = wasm.TS_FinalOnionHopData_clone_ptr(arg);
42922 return nativeResponseValue;
42924 // struct LDKFinalOnionHopData FinalOnionHopData_clone(const struct LDKFinalOnionHopData *NONNULL_PTR orig);
42926 export function FinalOnionHopData_clone(orig: bigint): bigint {
42927 if(!isWasmInitialized) {
42928 throw new Error("initializeWasm() must be awaited first!");
42930 const nativeResponseValue = wasm.TS_FinalOnionHopData_clone(orig);
42931 return nativeResponseValue;
42933 // void OnionPacket_free(struct LDKOnionPacket this_obj);
42935 export function OnionPacket_free(this_obj: bigint): void {
42936 if(!isWasmInitialized) {
42937 throw new Error("initializeWasm() must be awaited first!");
42939 const nativeResponseValue = wasm.TS_OnionPacket_free(this_obj);
42940 // debug statements here
42942 // uint8_t OnionPacket_get_version(const struct LDKOnionPacket *NONNULL_PTR this_ptr);
42944 export function OnionPacket_get_version(this_ptr: bigint): number {
42945 if(!isWasmInitialized) {
42946 throw new Error("initializeWasm() must be awaited first!");
42948 const nativeResponseValue = wasm.TS_OnionPacket_get_version(this_ptr);
42949 return nativeResponseValue;
42951 // void OnionPacket_set_version(struct LDKOnionPacket *NONNULL_PTR this_ptr, uint8_t val);
42953 export function OnionPacket_set_version(this_ptr: bigint, val: number): void {
42954 if(!isWasmInitialized) {
42955 throw new Error("initializeWasm() must be awaited first!");
42957 const nativeResponseValue = wasm.TS_OnionPacket_set_version(this_ptr, val);
42958 // debug statements here
42960 // struct LDKCResult_PublicKeySecp256k1ErrorZ OnionPacket_get_public_key(const struct LDKOnionPacket *NONNULL_PTR this_ptr);
42962 export function OnionPacket_get_public_key(this_ptr: bigint): bigint {
42963 if(!isWasmInitialized) {
42964 throw new Error("initializeWasm() must be awaited first!");
42966 const nativeResponseValue = wasm.TS_OnionPacket_get_public_key(this_ptr);
42967 return nativeResponseValue;
42969 // void OnionPacket_set_public_key(struct LDKOnionPacket *NONNULL_PTR this_ptr, struct LDKCResult_PublicKeySecp256k1ErrorZ val);
42971 export function OnionPacket_set_public_key(this_ptr: bigint, val: bigint): void {
42972 if(!isWasmInitialized) {
42973 throw new Error("initializeWasm() must be awaited first!");
42975 const nativeResponseValue = wasm.TS_OnionPacket_set_public_key(this_ptr, val);
42976 // debug statements here
42978 // const uint8_t (*OnionPacket_get_hmac(const struct LDKOnionPacket *NONNULL_PTR this_ptr))[32];
42980 export function OnionPacket_get_hmac(this_ptr: bigint): number {
42981 if(!isWasmInitialized) {
42982 throw new Error("initializeWasm() must be awaited first!");
42984 const nativeResponseValue = wasm.TS_OnionPacket_get_hmac(this_ptr);
42985 return nativeResponseValue;
42987 // void OnionPacket_set_hmac(struct LDKOnionPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42989 export function OnionPacket_set_hmac(this_ptr: bigint, val: number): void {
42990 if(!isWasmInitialized) {
42991 throw new Error("initializeWasm() must be awaited first!");
42993 const nativeResponseValue = wasm.TS_OnionPacket_set_hmac(this_ptr, val);
42994 // debug statements here
42996 // uint64_t OnionPacket_clone_ptr(LDKOnionPacket *NONNULL_PTR arg);
42998 export function OnionPacket_clone_ptr(arg: bigint): bigint {
42999 if(!isWasmInitialized) {
43000 throw new Error("initializeWasm() must be awaited first!");
43002 const nativeResponseValue = wasm.TS_OnionPacket_clone_ptr(arg);
43003 return nativeResponseValue;
43005 // struct LDKOnionPacket OnionPacket_clone(const struct LDKOnionPacket *NONNULL_PTR orig);
43007 export function OnionPacket_clone(orig: bigint): bigint {
43008 if(!isWasmInitialized) {
43009 throw new Error("initializeWasm() must be awaited first!");
43011 const nativeResponseValue = wasm.TS_OnionPacket_clone(orig);
43012 return nativeResponseValue;
43014 // uint64_t OnionPacket_hash(const struct LDKOnionPacket *NONNULL_PTR o);
43016 export function OnionPacket_hash(o: bigint): bigint {
43017 if(!isWasmInitialized) {
43018 throw new Error("initializeWasm() must be awaited first!");
43020 const nativeResponseValue = wasm.TS_OnionPacket_hash(o);
43021 return nativeResponseValue;
43023 // bool OnionPacket_eq(const struct LDKOnionPacket *NONNULL_PTR a, const struct LDKOnionPacket *NONNULL_PTR b);
43025 export function OnionPacket_eq(a: bigint, b: bigint): boolean {
43026 if(!isWasmInitialized) {
43027 throw new Error("initializeWasm() must be awaited first!");
43029 const nativeResponseValue = wasm.TS_OnionPacket_eq(a, b);
43030 return nativeResponseValue;
43032 // void TrampolineOnionPacket_free(struct LDKTrampolineOnionPacket this_obj);
43034 export function TrampolineOnionPacket_free(this_obj: bigint): void {
43035 if(!isWasmInitialized) {
43036 throw new Error("initializeWasm() must be awaited first!");
43038 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_free(this_obj);
43039 // debug statements here
43041 // uint8_t TrampolineOnionPacket_get_version(const struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr);
43043 export function TrampolineOnionPacket_get_version(this_ptr: bigint): number {
43044 if(!isWasmInitialized) {
43045 throw new Error("initializeWasm() must be awaited first!");
43047 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_get_version(this_ptr);
43048 return nativeResponseValue;
43050 // void TrampolineOnionPacket_set_version(struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr, uint8_t val);
43052 export function TrampolineOnionPacket_set_version(this_ptr: bigint, val: number): void {
43053 if(!isWasmInitialized) {
43054 throw new Error("initializeWasm() must be awaited first!");
43056 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_set_version(this_ptr, val);
43057 // debug statements here
43059 // struct LDKPublicKey TrampolineOnionPacket_get_public_key(const struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr);
43061 export function TrampolineOnionPacket_get_public_key(this_ptr: bigint): number {
43062 if(!isWasmInitialized) {
43063 throw new Error("initializeWasm() must be awaited first!");
43065 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_get_public_key(this_ptr);
43066 return nativeResponseValue;
43068 // void TrampolineOnionPacket_set_public_key(struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr, struct LDKPublicKey val);
43070 export function TrampolineOnionPacket_set_public_key(this_ptr: bigint, val: number): void {
43071 if(!isWasmInitialized) {
43072 throw new Error("initializeWasm() must be awaited first!");
43074 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_set_public_key(this_ptr, val);
43075 // debug statements here
43077 // struct LDKCVec_u8Z TrampolineOnionPacket_get_hop_data(const struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr);
43079 export function TrampolineOnionPacket_get_hop_data(this_ptr: bigint): number {
43080 if(!isWasmInitialized) {
43081 throw new Error("initializeWasm() must be awaited first!");
43083 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_get_hop_data(this_ptr);
43084 return nativeResponseValue;
43086 // void TrampolineOnionPacket_set_hop_data(struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
43088 export function TrampolineOnionPacket_set_hop_data(this_ptr: bigint, val: number): void {
43089 if(!isWasmInitialized) {
43090 throw new Error("initializeWasm() must be awaited first!");
43092 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_set_hop_data(this_ptr, val);
43093 // debug statements here
43095 // const uint8_t (*TrampolineOnionPacket_get_hmac(const struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr))[32];
43097 export function TrampolineOnionPacket_get_hmac(this_ptr: bigint): number {
43098 if(!isWasmInitialized) {
43099 throw new Error("initializeWasm() must be awaited first!");
43101 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_get_hmac(this_ptr);
43102 return nativeResponseValue;
43104 // void TrampolineOnionPacket_set_hmac(struct LDKTrampolineOnionPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
43106 export function TrampolineOnionPacket_set_hmac(this_ptr: bigint, val: number): void {
43107 if(!isWasmInitialized) {
43108 throw new Error("initializeWasm() must be awaited first!");
43110 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_set_hmac(this_ptr, val);
43111 // debug statements here
43113 // MUST_USE_RES struct LDKTrampolineOnionPacket TrampolineOnionPacket_new(uint8_t version_arg, struct LDKPublicKey public_key_arg, struct LDKCVec_u8Z hop_data_arg, struct LDKThirtyTwoBytes hmac_arg);
43115 export function TrampolineOnionPacket_new(version_arg: number, public_key_arg: number, hop_data_arg: number, hmac_arg: number): bigint {
43116 if(!isWasmInitialized) {
43117 throw new Error("initializeWasm() must be awaited first!");
43119 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_new(version_arg, public_key_arg, hop_data_arg, hmac_arg);
43120 return nativeResponseValue;
43122 // uint64_t TrampolineOnionPacket_clone_ptr(LDKTrampolineOnionPacket *NONNULL_PTR arg);
43124 export function TrampolineOnionPacket_clone_ptr(arg: bigint): bigint {
43125 if(!isWasmInitialized) {
43126 throw new Error("initializeWasm() must be awaited first!");
43128 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_clone_ptr(arg);
43129 return nativeResponseValue;
43131 // struct LDKTrampolineOnionPacket TrampolineOnionPacket_clone(const struct LDKTrampolineOnionPacket *NONNULL_PTR orig);
43133 export function TrampolineOnionPacket_clone(orig: bigint): bigint {
43134 if(!isWasmInitialized) {
43135 throw new Error("initializeWasm() must be awaited first!");
43137 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_clone(orig);
43138 return nativeResponseValue;
43140 // uint64_t TrampolineOnionPacket_hash(const struct LDKTrampolineOnionPacket *NONNULL_PTR o);
43142 export function TrampolineOnionPacket_hash(o: bigint): bigint {
43143 if(!isWasmInitialized) {
43144 throw new Error("initializeWasm() must be awaited first!");
43146 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_hash(o);
43147 return nativeResponseValue;
43149 // bool TrampolineOnionPacket_eq(const struct LDKTrampolineOnionPacket *NONNULL_PTR a, const struct LDKTrampolineOnionPacket *NONNULL_PTR b);
43151 export function TrampolineOnionPacket_eq(a: bigint, b: bigint): boolean {
43152 if(!isWasmInitialized) {
43153 throw new Error("initializeWasm() must be awaited first!");
43155 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_eq(a, b);
43156 return nativeResponseValue;
43158 // struct LDKCVec_u8Z TrampolineOnionPacket_write(const struct LDKTrampolineOnionPacket *NONNULL_PTR obj);
43160 export function TrampolineOnionPacket_write(obj: bigint): number {
43161 if(!isWasmInitialized) {
43162 throw new Error("initializeWasm() must be awaited first!");
43164 const nativeResponseValue = wasm.TS_TrampolineOnionPacket_write(obj);
43165 return nativeResponseValue;
43167 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
43169 export function AcceptChannel_write(obj: bigint): number {
43170 if(!isWasmInitialized) {
43171 throw new Error("initializeWasm() must be awaited first!");
43173 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
43174 return nativeResponseValue;
43176 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
43178 export function AcceptChannel_read(ser: number): bigint {
43179 if(!isWasmInitialized) {
43180 throw new Error("initializeWasm() must be awaited first!");
43182 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
43183 return nativeResponseValue;
43185 // struct LDKCVec_u8Z AcceptChannelV2_write(const struct LDKAcceptChannelV2 *NONNULL_PTR obj);
43187 export function AcceptChannelV2_write(obj: bigint): number {
43188 if(!isWasmInitialized) {
43189 throw new Error("initializeWasm() must be awaited first!");
43191 const nativeResponseValue = wasm.TS_AcceptChannelV2_write(obj);
43192 return nativeResponseValue;
43194 // struct LDKCResult_AcceptChannelV2DecodeErrorZ AcceptChannelV2_read(struct LDKu8slice ser);
43196 export function AcceptChannelV2_read(ser: number): bigint {
43197 if(!isWasmInitialized) {
43198 throw new Error("initializeWasm() must be awaited first!");
43200 const nativeResponseValue = wasm.TS_AcceptChannelV2_read(ser);
43201 return nativeResponseValue;
43203 // struct LDKCVec_u8Z Stfu_write(const struct LDKStfu *NONNULL_PTR obj);
43205 export function Stfu_write(obj: bigint): number {
43206 if(!isWasmInitialized) {
43207 throw new Error("initializeWasm() must be awaited first!");
43209 const nativeResponseValue = wasm.TS_Stfu_write(obj);
43210 return nativeResponseValue;
43212 // struct LDKCResult_StfuDecodeErrorZ Stfu_read(struct LDKu8slice ser);
43214 export function Stfu_read(ser: number): bigint {
43215 if(!isWasmInitialized) {
43216 throw new Error("initializeWasm() must be awaited first!");
43218 const nativeResponseValue = wasm.TS_Stfu_read(ser);
43219 return nativeResponseValue;
43221 // struct LDKCVec_u8Z Splice_write(const struct LDKSplice *NONNULL_PTR obj);
43223 export function Splice_write(obj: bigint): number {
43224 if(!isWasmInitialized) {
43225 throw new Error("initializeWasm() must be awaited first!");
43227 const nativeResponseValue = wasm.TS_Splice_write(obj);
43228 return nativeResponseValue;
43230 // struct LDKCResult_SpliceDecodeErrorZ Splice_read(struct LDKu8slice ser);
43232 export function Splice_read(ser: number): bigint {
43233 if(!isWasmInitialized) {
43234 throw new Error("initializeWasm() must be awaited first!");
43236 const nativeResponseValue = wasm.TS_Splice_read(ser);
43237 return nativeResponseValue;
43239 // struct LDKCVec_u8Z SpliceAck_write(const struct LDKSpliceAck *NONNULL_PTR obj);
43241 export function SpliceAck_write(obj: bigint): number {
43242 if(!isWasmInitialized) {
43243 throw new Error("initializeWasm() must be awaited first!");
43245 const nativeResponseValue = wasm.TS_SpliceAck_write(obj);
43246 return nativeResponseValue;
43248 // struct LDKCResult_SpliceAckDecodeErrorZ SpliceAck_read(struct LDKu8slice ser);
43250 export function SpliceAck_read(ser: number): bigint {
43251 if(!isWasmInitialized) {
43252 throw new Error("initializeWasm() must be awaited first!");
43254 const nativeResponseValue = wasm.TS_SpliceAck_read(ser);
43255 return nativeResponseValue;
43257 // struct LDKCVec_u8Z SpliceLocked_write(const struct LDKSpliceLocked *NONNULL_PTR obj);
43259 export function SpliceLocked_write(obj: bigint): number {
43260 if(!isWasmInitialized) {
43261 throw new Error("initializeWasm() must be awaited first!");
43263 const nativeResponseValue = wasm.TS_SpliceLocked_write(obj);
43264 return nativeResponseValue;
43266 // struct LDKCResult_SpliceLockedDecodeErrorZ SpliceLocked_read(struct LDKu8slice ser);
43268 export function SpliceLocked_read(ser: number): bigint {
43269 if(!isWasmInitialized) {
43270 throw new Error("initializeWasm() must be awaited first!");
43272 const nativeResponseValue = wasm.TS_SpliceLocked_read(ser);
43273 return nativeResponseValue;
43275 // struct LDKCVec_u8Z TxAddInput_write(const struct LDKTxAddInput *NONNULL_PTR obj);
43277 export function TxAddInput_write(obj: bigint): number {
43278 if(!isWasmInitialized) {
43279 throw new Error("initializeWasm() must be awaited first!");
43281 const nativeResponseValue = wasm.TS_TxAddInput_write(obj);
43282 return nativeResponseValue;
43284 // struct LDKCResult_TxAddInputDecodeErrorZ TxAddInput_read(struct LDKu8slice ser);
43286 export function TxAddInput_read(ser: number): bigint {
43287 if(!isWasmInitialized) {
43288 throw new Error("initializeWasm() must be awaited first!");
43290 const nativeResponseValue = wasm.TS_TxAddInput_read(ser);
43291 return nativeResponseValue;
43293 // struct LDKCVec_u8Z TxAddOutput_write(const struct LDKTxAddOutput *NONNULL_PTR obj);
43295 export function TxAddOutput_write(obj: bigint): number {
43296 if(!isWasmInitialized) {
43297 throw new Error("initializeWasm() must be awaited first!");
43299 const nativeResponseValue = wasm.TS_TxAddOutput_write(obj);
43300 return nativeResponseValue;
43302 // struct LDKCResult_TxAddOutputDecodeErrorZ TxAddOutput_read(struct LDKu8slice ser);
43304 export function TxAddOutput_read(ser: number): bigint {
43305 if(!isWasmInitialized) {
43306 throw new Error("initializeWasm() must be awaited first!");
43308 const nativeResponseValue = wasm.TS_TxAddOutput_read(ser);
43309 return nativeResponseValue;
43311 // struct LDKCVec_u8Z TxRemoveInput_write(const struct LDKTxRemoveInput *NONNULL_PTR obj);
43313 export function TxRemoveInput_write(obj: bigint): number {
43314 if(!isWasmInitialized) {
43315 throw new Error("initializeWasm() must be awaited first!");
43317 const nativeResponseValue = wasm.TS_TxRemoveInput_write(obj);
43318 return nativeResponseValue;
43320 // struct LDKCResult_TxRemoveInputDecodeErrorZ TxRemoveInput_read(struct LDKu8slice ser);
43322 export function TxRemoveInput_read(ser: number): bigint {
43323 if(!isWasmInitialized) {
43324 throw new Error("initializeWasm() must be awaited first!");
43326 const nativeResponseValue = wasm.TS_TxRemoveInput_read(ser);
43327 return nativeResponseValue;
43329 // struct LDKCVec_u8Z TxRemoveOutput_write(const struct LDKTxRemoveOutput *NONNULL_PTR obj);
43331 export function TxRemoveOutput_write(obj: bigint): number {
43332 if(!isWasmInitialized) {
43333 throw new Error("initializeWasm() must be awaited first!");
43335 const nativeResponseValue = wasm.TS_TxRemoveOutput_write(obj);
43336 return nativeResponseValue;
43338 // struct LDKCResult_TxRemoveOutputDecodeErrorZ TxRemoveOutput_read(struct LDKu8slice ser);
43340 export function TxRemoveOutput_read(ser: number): bigint {
43341 if(!isWasmInitialized) {
43342 throw new Error("initializeWasm() must be awaited first!");
43344 const nativeResponseValue = wasm.TS_TxRemoveOutput_read(ser);
43345 return nativeResponseValue;
43347 // struct LDKCVec_u8Z TxComplete_write(const struct LDKTxComplete *NONNULL_PTR obj);
43349 export function TxComplete_write(obj: bigint): number {
43350 if(!isWasmInitialized) {
43351 throw new Error("initializeWasm() must be awaited first!");
43353 const nativeResponseValue = wasm.TS_TxComplete_write(obj);
43354 return nativeResponseValue;
43356 // struct LDKCResult_TxCompleteDecodeErrorZ TxComplete_read(struct LDKu8slice ser);
43358 export function TxComplete_read(ser: number): bigint {
43359 if(!isWasmInitialized) {
43360 throw new Error("initializeWasm() must be awaited first!");
43362 const nativeResponseValue = wasm.TS_TxComplete_read(ser);
43363 return nativeResponseValue;
43365 // struct LDKCVec_u8Z TxSignatures_write(const struct LDKTxSignatures *NONNULL_PTR obj);
43367 export function TxSignatures_write(obj: bigint): number {
43368 if(!isWasmInitialized) {
43369 throw new Error("initializeWasm() must be awaited first!");
43371 const nativeResponseValue = wasm.TS_TxSignatures_write(obj);
43372 return nativeResponseValue;
43374 // struct LDKCResult_TxSignaturesDecodeErrorZ TxSignatures_read(struct LDKu8slice ser);
43376 export function TxSignatures_read(ser: number): bigint {
43377 if(!isWasmInitialized) {
43378 throw new Error("initializeWasm() must be awaited first!");
43380 const nativeResponseValue = wasm.TS_TxSignatures_read(ser);
43381 return nativeResponseValue;
43383 // struct LDKCVec_u8Z TxInitRbf_write(const struct LDKTxInitRbf *NONNULL_PTR obj);
43385 export function TxInitRbf_write(obj: bigint): number {
43386 if(!isWasmInitialized) {
43387 throw new Error("initializeWasm() must be awaited first!");
43389 const nativeResponseValue = wasm.TS_TxInitRbf_write(obj);
43390 return nativeResponseValue;
43392 // struct LDKCResult_TxInitRbfDecodeErrorZ TxInitRbf_read(struct LDKu8slice ser);
43394 export function TxInitRbf_read(ser: number): bigint {
43395 if(!isWasmInitialized) {
43396 throw new Error("initializeWasm() must be awaited first!");
43398 const nativeResponseValue = wasm.TS_TxInitRbf_read(ser);
43399 return nativeResponseValue;
43401 // struct LDKCVec_u8Z TxAckRbf_write(const struct LDKTxAckRbf *NONNULL_PTR obj);
43403 export function TxAckRbf_write(obj: bigint): number {
43404 if(!isWasmInitialized) {
43405 throw new Error("initializeWasm() must be awaited first!");
43407 const nativeResponseValue = wasm.TS_TxAckRbf_write(obj);
43408 return nativeResponseValue;
43410 // struct LDKCResult_TxAckRbfDecodeErrorZ TxAckRbf_read(struct LDKu8slice ser);
43412 export function TxAckRbf_read(ser: number): bigint {
43413 if(!isWasmInitialized) {
43414 throw new Error("initializeWasm() must be awaited first!");
43416 const nativeResponseValue = wasm.TS_TxAckRbf_read(ser);
43417 return nativeResponseValue;
43419 // struct LDKCVec_u8Z TxAbort_write(const struct LDKTxAbort *NONNULL_PTR obj);
43421 export function TxAbort_write(obj: bigint): number {
43422 if(!isWasmInitialized) {
43423 throw new Error("initializeWasm() must be awaited first!");
43425 const nativeResponseValue = wasm.TS_TxAbort_write(obj);
43426 return nativeResponseValue;
43428 // struct LDKCResult_TxAbortDecodeErrorZ TxAbort_read(struct LDKu8slice ser);
43430 export function TxAbort_read(ser: number): bigint {
43431 if(!isWasmInitialized) {
43432 throw new Error("initializeWasm() must be awaited first!");
43434 const nativeResponseValue = wasm.TS_TxAbort_read(ser);
43435 return nativeResponseValue;
43437 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
43439 export function AnnouncementSignatures_write(obj: bigint): number {
43440 if(!isWasmInitialized) {
43441 throw new Error("initializeWasm() must be awaited first!");
43443 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
43444 return nativeResponseValue;
43446 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
43448 export function AnnouncementSignatures_read(ser: number): bigint {
43449 if(!isWasmInitialized) {
43450 throw new Error("initializeWasm() must be awaited first!");
43452 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
43453 return nativeResponseValue;
43455 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
43457 export function ChannelReestablish_write(obj: bigint): number {
43458 if(!isWasmInitialized) {
43459 throw new Error("initializeWasm() must be awaited first!");
43461 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
43462 return nativeResponseValue;
43464 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
43466 export function ChannelReestablish_read(ser: number): bigint {
43467 if(!isWasmInitialized) {
43468 throw new Error("initializeWasm() must be awaited first!");
43470 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
43471 return nativeResponseValue;
43473 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
43475 export function ClosingSigned_write(obj: bigint): number {
43476 if(!isWasmInitialized) {
43477 throw new Error("initializeWasm() must be awaited first!");
43479 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
43480 return nativeResponseValue;
43482 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
43484 export function ClosingSigned_read(ser: number): bigint {
43485 if(!isWasmInitialized) {
43486 throw new Error("initializeWasm() must be awaited first!");
43488 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
43489 return nativeResponseValue;
43491 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
43493 export function ClosingSignedFeeRange_write(obj: bigint): number {
43494 if(!isWasmInitialized) {
43495 throw new Error("initializeWasm() must be awaited first!");
43497 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
43498 return nativeResponseValue;
43500 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
43502 export function ClosingSignedFeeRange_read(ser: number): bigint {
43503 if(!isWasmInitialized) {
43504 throw new Error("initializeWasm() must be awaited first!");
43506 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
43507 return nativeResponseValue;
43509 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
43511 export function CommitmentSigned_write(obj: bigint): number {
43512 if(!isWasmInitialized) {
43513 throw new Error("initializeWasm() must be awaited first!");
43515 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
43516 return nativeResponseValue;
43518 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
43520 export function CommitmentSigned_read(ser: number): bigint {
43521 if(!isWasmInitialized) {
43522 throw new Error("initializeWasm() must be awaited first!");
43524 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
43525 return nativeResponseValue;
43527 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
43529 export function FundingCreated_write(obj: bigint): number {
43530 if(!isWasmInitialized) {
43531 throw new Error("initializeWasm() must be awaited first!");
43533 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
43534 return nativeResponseValue;
43536 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
43538 export function FundingCreated_read(ser: number): bigint {
43539 if(!isWasmInitialized) {
43540 throw new Error("initializeWasm() must be awaited first!");
43542 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
43543 return nativeResponseValue;
43545 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
43547 export function FundingSigned_write(obj: bigint): number {
43548 if(!isWasmInitialized) {
43549 throw new Error("initializeWasm() must be awaited first!");
43551 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
43552 return nativeResponseValue;
43554 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
43556 export function FundingSigned_read(ser: number): bigint {
43557 if(!isWasmInitialized) {
43558 throw new Error("initializeWasm() must be awaited first!");
43560 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
43561 return nativeResponseValue;
43563 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
43565 export function ChannelReady_write(obj: bigint): number {
43566 if(!isWasmInitialized) {
43567 throw new Error("initializeWasm() must be awaited first!");
43569 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
43570 return nativeResponseValue;
43572 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
43574 export function ChannelReady_read(ser: number): bigint {
43575 if(!isWasmInitialized) {
43576 throw new Error("initializeWasm() must be awaited first!");
43578 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
43579 return nativeResponseValue;
43581 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
43583 export function Init_write(obj: bigint): number {
43584 if(!isWasmInitialized) {
43585 throw new Error("initializeWasm() must be awaited first!");
43587 const nativeResponseValue = wasm.TS_Init_write(obj);
43588 return nativeResponseValue;
43590 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
43592 export function Init_read(ser: number): bigint {
43593 if(!isWasmInitialized) {
43594 throw new Error("initializeWasm() must be awaited first!");
43596 const nativeResponseValue = wasm.TS_Init_read(ser);
43597 return nativeResponseValue;
43599 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
43601 export function OpenChannel_write(obj: bigint): number {
43602 if(!isWasmInitialized) {
43603 throw new Error("initializeWasm() must be awaited first!");
43605 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
43606 return nativeResponseValue;
43608 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
43610 export function OpenChannel_read(ser: number): bigint {
43611 if(!isWasmInitialized) {
43612 throw new Error("initializeWasm() must be awaited first!");
43614 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
43615 return nativeResponseValue;
43617 // struct LDKCVec_u8Z OpenChannelV2_write(const struct LDKOpenChannelV2 *NONNULL_PTR obj);
43619 export function OpenChannelV2_write(obj: bigint): number {
43620 if(!isWasmInitialized) {
43621 throw new Error("initializeWasm() must be awaited first!");
43623 const nativeResponseValue = wasm.TS_OpenChannelV2_write(obj);
43624 return nativeResponseValue;
43626 // struct LDKCResult_OpenChannelV2DecodeErrorZ OpenChannelV2_read(struct LDKu8slice ser);
43628 export function OpenChannelV2_read(ser: number): bigint {
43629 if(!isWasmInitialized) {
43630 throw new Error("initializeWasm() must be awaited first!");
43632 const nativeResponseValue = wasm.TS_OpenChannelV2_read(ser);
43633 return nativeResponseValue;
43635 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
43637 export function RevokeAndACK_write(obj: bigint): number {
43638 if(!isWasmInitialized) {
43639 throw new Error("initializeWasm() must be awaited first!");
43641 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
43642 return nativeResponseValue;
43644 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
43646 export function RevokeAndACK_read(ser: number): bigint {
43647 if(!isWasmInitialized) {
43648 throw new Error("initializeWasm() must be awaited first!");
43650 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
43651 return nativeResponseValue;
43653 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
43655 export function Shutdown_write(obj: bigint): number {
43656 if(!isWasmInitialized) {
43657 throw new Error("initializeWasm() must be awaited first!");
43659 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
43660 return nativeResponseValue;
43662 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
43664 export function Shutdown_read(ser: number): bigint {
43665 if(!isWasmInitialized) {
43666 throw new Error("initializeWasm() must be awaited first!");
43668 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
43669 return nativeResponseValue;
43671 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
43673 export function UpdateFailHTLC_write(obj: bigint): number {
43674 if(!isWasmInitialized) {
43675 throw new Error("initializeWasm() must be awaited first!");
43677 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
43678 return nativeResponseValue;
43680 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
43682 export function UpdateFailHTLC_read(ser: number): bigint {
43683 if(!isWasmInitialized) {
43684 throw new Error("initializeWasm() must be awaited first!");
43686 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
43687 return nativeResponseValue;
43689 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
43691 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
43692 if(!isWasmInitialized) {
43693 throw new Error("initializeWasm() must be awaited first!");
43695 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
43696 return nativeResponseValue;
43698 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
43700 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
43701 if(!isWasmInitialized) {
43702 throw new Error("initializeWasm() must be awaited first!");
43704 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
43705 return nativeResponseValue;
43707 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
43709 export function UpdateFee_write(obj: bigint): number {
43710 if(!isWasmInitialized) {
43711 throw new Error("initializeWasm() must be awaited first!");
43713 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
43714 return nativeResponseValue;
43716 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
43718 export function UpdateFee_read(ser: number): bigint {
43719 if(!isWasmInitialized) {
43720 throw new Error("initializeWasm() must be awaited first!");
43722 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
43723 return nativeResponseValue;
43725 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
43727 export function UpdateFulfillHTLC_write(obj: bigint): number {
43728 if(!isWasmInitialized) {
43729 throw new Error("initializeWasm() must be awaited first!");
43731 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
43732 return nativeResponseValue;
43734 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
43736 export function UpdateFulfillHTLC_read(ser: number): bigint {
43737 if(!isWasmInitialized) {
43738 throw new Error("initializeWasm() must be awaited first!");
43740 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
43741 return nativeResponseValue;
43743 // struct LDKCVec_u8Z OnionPacket_write(const struct LDKOnionPacket *NONNULL_PTR obj);
43745 export function OnionPacket_write(obj: bigint): number {
43746 if(!isWasmInitialized) {
43747 throw new Error("initializeWasm() must be awaited first!");
43749 const nativeResponseValue = wasm.TS_OnionPacket_write(obj);
43750 return nativeResponseValue;
43752 // struct LDKCResult_OnionPacketDecodeErrorZ OnionPacket_read(struct LDKu8slice ser);
43754 export function OnionPacket_read(ser: number): bigint {
43755 if(!isWasmInitialized) {
43756 throw new Error("initializeWasm() must be awaited first!");
43758 const nativeResponseValue = wasm.TS_OnionPacket_read(ser);
43759 return nativeResponseValue;
43761 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
43763 export function UpdateAddHTLC_write(obj: bigint): number {
43764 if(!isWasmInitialized) {
43765 throw new Error("initializeWasm() must be awaited first!");
43767 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
43768 return nativeResponseValue;
43770 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
43772 export function UpdateAddHTLC_read(ser: number): bigint {
43773 if(!isWasmInitialized) {
43774 throw new Error("initializeWasm() must be awaited first!");
43776 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
43777 return nativeResponseValue;
43779 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
43781 export function OnionMessage_read(ser: number): bigint {
43782 if(!isWasmInitialized) {
43783 throw new Error("initializeWasm() must be awaited first!");
43785 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
43786 return nativeResponseValue;
43788 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
43790 export function OnionMessage_write(obj: bigint): number {
43791 if(!isWasmInitialized) {
43792 throw new Error("initializeWasm() must be awaited first!");
43794 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
43795 return nativeResponseValue;
43797 // struct LDKCVec_u8Z FinalOnionHopData_write(const struct LDKFinalOnionHopData *NONNULL_PTR obj);
43799 export function FinalOnionHopData_write(obj: bigint): number {
43800 if(!isWasmInitialized) {
43801 throw new Error("initializeWasm() must be awaited first!");
43803 const nativeResponseValue = wasm.TS_FinalOnionHopData_write(obj);
43804 return nativeResponseValue;
43806 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ FinalOnionHopData_read(struct LDKu8slice ser);
43808 export function FinalOnionHopData_read(ser: number): bigint {
43809 if(!isWasmInitialized) {
43810 throw new Error("initializeWasm() must be awaited first!");
43812 const nativeResponseValue = wasm.TS_FinalOnionHopData_read(ser);
43813 return nativeResponseValue;
43815 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
43817 export function Ping_write(obj: bigint): number {
43818 if(!isWasmInitialized) {
43819 throw new Error("initializeWasm() must be awaited first!");
43821 const nativeResponseValue = wasm.TS_Ping_write(obj);
43822 return nativeResponseValue;
43824 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
43826 export function Ping_read(ser: number): bigint {
43827 if(!isWasmInitialized) {
43828 throw new Error("initializeWasm() must be awaited first!");
43830 const nativeResponseValue = wasm.TS_Ping_read(ser);
43831 return nativeResponseValue;
43833 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
43835 export function Pong_write(obj: bigint): number {
43836 if(!isWasmInitialized) {
43837 throw new Error("initializeWasm() must be awaited first!");
43839 const nativeResponseValue = wasm.TS_Pong_write(obj);
43840 return nativeResponseValue;
43842 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
43844 export function Pong_read(ser: number): bigint {
43845 if(!isWasmInitialized) {
43846 throw new Error("initializeWasm() must be awaited first!");
43848 const nativeResponseValue = wasm.TS_Pong_read(ser);
43849 return nativeResponseValue;
43851 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
43853 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
43854 if(!isWasmInitialized) {
43855 throw new Error("initializeWasm() must be awaited first!");
43857 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
43858 return nativeResponseValue;
43860 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
43862 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
43863 if(!isWasmInitialized) {
43864 throw new Error("initializeWasm() must be awaited first!");
43866 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
43867 return nativeResponseValue;
43869 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
43871 export function ChannelAnnouncement_write(obj: bigint): number {
43872 if(!isWasmInitialized) {
43873 throw new Error("initializeWasm() must be awaited first!");
43875 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
43876 return nativeResponseValue;
43878 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
43880 export function ChannelAnnouncement_read(ser: number): bigint {
43881 if(!isWasmInitialized) {
43882 throw new Error("initializeWasm() must be awaited first!");
43884 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
43885 return nativeResponseValue;
43887 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
43889 export function UnsignedChannelUpdate_write(obj: bigint): number {
43890 if(!isWasmInitialized) {
43891 throw new Error("initializeWasm() must be awaited first!");
43893 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
43894 return nativeResponseValue;
43896 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
43898 export function UnsignedChannelUpdate_read(ser: number): bigint {
43899 if(!isWasmInitialized) {
43900 throw new Error("initializeWasm() must be awaited first!");
43902 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
43903 return nativeResponseValue;
43905 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
43907 export function ChannelUpdate_write(obj: bigint): number {
43908 if(!isWasmInitialized) {
43909 throw new Error("initializeWasm() must be awaited first!");
43911 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
43912 return nativeResponseValue;
43914 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
43916 export function ChannelUpdate_read(ser: number): bigint {
43917 if(!isWasmInitialized) {
43918 throw new Error("initializeWasm() must be awaited first!");
43920 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
43921 return nativeResponseValue;
43923 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
43925 export function ErrorMessage_write(obj: bigint): number {
43926 if(!isWasmInitialized) {
43927 throw new Error("initializeWasm() must be awaited first!");
43929 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
43930 return nativeResponseValue;
43932 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
43934 export function ErrorMessage_read(ser: number): bigint {
43935 if(!isWasmInitialized) {
43936 throw new Error("initializeWasm() must be awaited first!");
43938 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
43939 return nativeResponseValue;
43941 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
43943 export function WarningMessage_write(obj: bigint): number {
43944 if(!isWasmInitialized) {
43945 throw new Error("initializeWasm() must be awaited first!");
43947 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
43948 return nativeResponseValue;
43950 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
43952 export function WarningMessage_read(ser: number): bigint {
43953 if(!isWasmInitialized) {
43954 throw new Error("initializeWasm() must be awaited first!");
43956 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
43957 return nativeResponseValue;
43959 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
43961 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
43962 if(!isWasmInitialized) {
43963 throw new Error("initializeWasm() must be awaited first!");
43965 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
43966 return nativeResponseValue;
43968 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
43970 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
43971 if(!isWasmInitialized) {
43972 throw new Error("initializeWasm() must be awaited first!");
43974 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
43975 return nativeResponseValue;
43977 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
43979 export function NodeAnnouncement_write(obj: bigint): number {
43980 if(!isWasmInitialized) {
43981 throw new Error("initializeWasm() must be awaited first!");
43983 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
43984 return nativeResponseValue;
43986 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
43988 export function NodeAnnouncement_read(ser: number): bigint {
43989 if(!isWasmInitialized) {
43990 throw new Error("initializeWasm() must be awaited first!");
43992 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
43993 return nativeResponseValue;
43995 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
43997 export function QueryShortChannelIds_read(ser: number): bigint {
43998 if(!isWasmInitialized) {
43999 throw new Error("initializeWasm() must be awaited first!");
44001 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
44002 return nativeResponseValue;
44004 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
44006 export function QueryShortChannelIds_write(obj: bigint): number {
44007 if(!isWasmInitialized) {
44008 throw new Error("initializeWasm() must be awaited first!");
44010 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
44011 return nativeResponseValue;
44013 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
44015 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
44016 if(!isWasmInitialized) {
44017 throw new Error("initializeWasm() must be awaited first!");
44019 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
44020 return nativeResponseValue;
44022 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
44024 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
44025 if(!isWasmInitialized) {
44026 throw new Error("initializeWasm() must be awaited first!");
44028 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
44029 return nativeResponseValue;
44031 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
44033 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
44034 if(!isWasmInitialized) {
44035 throw new Error("initializeWasm() must be awaited first!");
44037 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
44038 return nativeResponseValue;
44040 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
44042 export function QueryChannelRange_write(obj: bigint): number {
44043 if(!isWasmInitialized) {
44044 throw new Error("initializeWasm() must be awaited first!");
44046 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
44047 return nativeResponseValue;
44049 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
44051 export function QueryChannelRange_read(ser: number): bigint {
44052 if(!isWasmInitialized) {
44053 throw new Error("initializeWasm() must be awaited first!");
44055 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
44056 return nativeResponseValue;
44058 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
44060 export function ReplyChannelRange_read(ser: number): bigint {
44061 if(!isWasmInitialized) {
44062 throw new Error("initializeWasm() must be awaited first!");
44064 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
44065 return nativeResponseValue;
44067 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
44069 export function ReplyChannelRange_write(obj: bigint): number {
44070 if(!isWasmInitialized) {
44071 throw new Error("initializeWasm() must be awaited first!");
44073 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
44074 return nativeResponseValue;
44076 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
44078 export function GossipTimestampFilter_write(obj: bigint): number {
44079 if(!isWasmInitialized) {
44080 throw new Error("initializeWasm() must be awaited first!");
44082 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
44083 return nativeResponseValue;
44085 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
44087 export function GossipTimestampFilter_read(ser: number): bigint {
44088 if(!isWasmInitialized) {
44089 throw new Error("initializeWasm() must be awaited first!");
44091 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
44092 return nativeResponseValue;
44094 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
44096 export function CustomMessageHandler_free(this_ptr: bigint): void {
44097 if(!isWasmInitialized) {
44098 throw new Error("initializeWasm() must be awaited first!");
44100 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
44101 // debug statements here
44103 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
44105 export function IgnoringMessageHandler_free(this_obj: bigint): void {
44106 if(!isWasmInitialized) {
44107 throw new Error("initializeWasm() must be awaited first!");
44109 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
44110 // debug statements here
44112 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
44114 export function IgnoringMessageHandler_new(): bigint {
44115 if(!isWasmInitialized) {
44116 throw new Error("initializeWasm() must be awaited first!");
44118 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
44119 return nativeResponseValue;
44121 // struct LDKEventsProvider IgnoringMessageHandler_as_EventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44123 export function IgnoringMessageHandler_as_EventsProvider(this_arg: bigint): bigint {
44124 if(!isWasmInitialized) {
44125 throw new Error("initializeWasm() must be awaited first!");
44127 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_EventsProvider(this_arg);
44128 return nativeResponseValue;
44130 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44132 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
44133 if(!isWasmInitialized) {
44134 throw new Error("initializeWasm() must be awaited first!");
44136 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
44137 return nativeResponseValue;
44139 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44141 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
44142 if(!isWasmInitialized) {
44143 throw new Error("initializeWasm() must be awaited first!");
44145 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
44146 return nativeResponseValue;
44148 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44150 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
44151 if(!isWasmInitialized) {
44152 throw new Error("initializeWasm() must be awaited first!");
44154 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
44155 return nativeResponseValue;
44157 // struct LDKOffersMessageHandler IgnoringMessageHandler_as_OffersMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44159 export function IgnoringMessageHandler_as_OffersMessageHandler(this_arg: bigint): bigint {
44160 if(!isWasmInitialized) {
44161 throw new Error("initializeWasm() must be awaited first!");
44163 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OffersMessageHandler(this_arg);
44164 return nativeResponseValue;
44166 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44168 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
44169 if(!isWasmInitialized) {
44170 throw new Error("initializeWasm() must be awaited first!");
44172 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
44173 return nativeResponseValue;
44175 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44177 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
44178 if(!isWasmInitialized) {
44179 throw new Error("initializeWasm() must be awaited first!");
44181 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
44182 return nativeResponseValue;
44184 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
44186 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
44187 if(!isWasmInitialized) {
44188 throw new Error("initializeWasm() must be awaited first!");
44190 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
44191 return nativeResponseValue;
44193 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
44195 export function ErroringMessageHandler_free(this_obj: bigint): void {
44196 if(!isWasmInitialized) {
44197 throw new Error("initializeWasm() must be awaited first!");
44199 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
44200 // debug statements here
44202 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
44204 export function ErroringMessageHandler_new(): bigint {
44205 if(!isWasmInitialized) {
44206 throw new Error("initializeWasm() must be awaited first!");
44208 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
44209 return nativeResponseValue;
44211 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
44213 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
44214 if(!isWasmInitialized) {
44215 throw new Error("initializeWasm() must be awaited first!");
44217 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
44218 return nativeResponseValue;
44220 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
44222 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
44223 if(!isWasmInitialized) {
44224 throw new Error("initializeWasm() must be awaited first!");
44226 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
44227 return nativeResponseValue;
44229 // void MessageHandler_free(struct LDKMessageHandler this_obj);
44231 export function MessageHandler_free(this_obj: bigint): void {
44232 if(!isWasmInitialized) {
44233 throw new Error("initializeWasm() must be awaited first!");
44235 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
44236 // debug statements here
44238 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
44240 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
44241 if(!isWasmInitialized) {
44242 throw new Error("initializeWasm() must be awaited first!");
44244 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
44245 return nativeResponseValue;
44247 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
44249 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
44250 if(!isWasmInitialized) {
44251 throw new Error("initializeWasm() must be awaited first!");
44253 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
44254 // debug statements here
44256 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
44258 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
44259 if(!isWasmInitialized) {
44260 throw new Error("initializeWasm() must be awaited first!");
44262 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
44263 return nativeResponseValue;
44265 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
44267 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
44268 if(!isWasmInitialized) {
44269 throw new Error("initializeWasm() must be awaited first!");
44271 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
44272 // debug statements here
44274 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
44276 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
44277 if(!isWasmInitialized) {
44278 throw new Error("initializeWasm() must be awaited first!");
44280 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
44281 return nativeResponseValue;
44283 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
44285 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
44286 if(!isWasmInitialized) {
44287 throw new Error("initializeWasm() must be awaited first!");
44289 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
44290 // debug statements here
44292 // const struct LDKCustomMessageHandler *MessageHandler_get_custom_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
44294 export function MessageHandler_get_custom_message_handler(this_ptr: bigint): bigint {
44295 if(!isWasmInitialized) {
44296 throw new Error("initializeWasm() must be awaited first!");
44298 const nativeResponseValue = wasm.TS_MessageHandler_get_custom_message_handler(this_ptr);
44299 return nativeResponseValue;
44301 // void MessageHandler_set_custom_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKCustomMessageHandler val);
44303 export function MessageHandler_set_custom_message_handler(this_ptr: bigint, val: bigint): void {
44304 if(!isWasmInitialized) {
44305 throw new Error("initializeWasm() must be awaited first!");
44307 const nativeResponseValue = wasm.TS_MessageHandler_set_custom_message_handler(this_ptr, val);
44308 // debug statements here
44310 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg, struct LDKCustomMessageHandler custom_message_handler_arg);
44312 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint, custom_message_handler_arg: bigint): bigint {
44313 if(!isWasmInitialized) {
44314 throw new Error("initializeWasm() must be awaited first!");
44316 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg, custom_message_handler_arg);
44317 return nativeResponseValue;
44319 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
44321 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
44322 if(!isWasmInitialized) {
44323 throw new Error("initializeWasm() must be awaited first!");
44325 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
44326 return nativeResponseValue;
44328 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
44330 export function SocketDescriptor_clone(orig: bigint): bigint {
44331 if(!isWasmInitialized) {
44332 throw new Error("initializeWasm() must be awaited first!");
44334 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
44335 return nativeResponseValue;
44337 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
44339 export function SocketDescriptor_free(this_ptr: bigint): void {
44340 if(!isWasmInitialized) {
44341 throw new Error("initializeWasm() must be awaited first!");
44343 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
44344 // debug statements here
44346 // void PeerDetails_free(struct LDKPeerDetails this_obj);
44348 export function PeerDetails_free(this_obj: bigint): void {
44349 if(!isWasmInitialized) {
44350 throw new Error("initializeWasm() must be awaited first!");
44352 const nativeResponseValue = wasm.TS_PeerDetails_free(this_obj);
44353 // debug statements here
44355 // struct LDKPublicKey PeerDetails_get_counterparty_node_id(const struct LDKPeerDetails *NONNULL_PTR this_ptr);
44357 export function PeerDetails_get_counterparty_node_id(this_ptr: bigint): number {
44358 if(!isWasmInitialized) {
44359 throw new Error("initializeWasm() must be awaited first!");
44361 const nativeResponseValue = wasm.TS_PeerDetails_get_counterparty_node_id(this_ptr);
44362 return nativeResponseValue;
44364 // void PeerDetails_set_counterparty_node_id(struct LDKPeerDetails *NONNULL_PTR this_ptr, struct LDKPublicKey val);
44366 export function PeerDetails_set_counterparty_node_id(this_ptr: bigint, val: number): void {
44367 if(!isWasmInitialized) {
44368 throw new Error("initializeWasm() must be awaited first!");
44370 const nativeResponseValue = wasm.TS_PeerDetails_set_counterparty_node_id(this_ptr, val);
44371 // debug statements here
44373 // struct LDKCOption_SocketAddressZ PeerDetails_get_socket_address(const struct LDKPeerDetails *NONNULL_PTR this_ptr);
44375 export function PeerDetails_get_socket_address(this_ptr: bigint): bigint {
44376 if(!isWasmInitialized) {
44377 throw new Error("initializeWasm() must be awaited first!");
44379 const nativeResponseValue = wasm.TS_PeerDetails_get_socket_address(this_ptr);
44380 return nativeResponseValue;
44382 // void PeerDetails_set_socket_address(struct LDKPeerDetails *NONNULL_PTR this_ptr, struct LDKCOption_SocketAddressZ val);
44384 export function PeerDetails_set_socket_address(this_ptr: bigint, val: bigint): void {
44385 if(!isWasmInitialized) {
44386 throw new Error("initializeWasm() must be awaited first!");
44388 const nativeResponseValue = wasm.TS_PeerDetails_set_socket_address(this_ptr, val);
44389 // debug statements here
44391 // struct LDKInitFeatures PeerDetails_get_init_features(const struct LDKPeerDetails *NONNULL_PTR this_ptr);
44393 export function PeerDetails_get_init_features(this_ptr: bigint): bigint {
44394 if(!isWasmInitialized) {
44395 throw new Error("initializeWasm() must be awaited first!");
44397 const nativeResponseValue = wasm.TS_PeerDetails_get_init_features(this_ptr);
44398 return nativeResponseValue;
44400 // void PeerDetails_set_init_features(struct LDKPeerDetails *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
44402 export function PeerDetails_set_init_features(this_ptr: bigint, val: bigint): void {
44403 if(!isWasmInitialized) {
44404 throw new Error("initializeWasm() must be awaited first!");
44406 const nativeResponseValue = wasm.TS_PeerDetails_set_init_features(this_ptr, val);
44407 // debug statements here
44409 // bool PeerDetails_get_is_inbound_connection(const struct LDKPeerDetails *NONNULL_PTR this_ptr);
44411 export function PeerDetails_get_is_inbound_connection(this_ptr: bigint): boolean {
44412 if(!isWasmInitialized) {
44413 throw new Error("initializeWasm() must be awaited first!");
44415 const nativeResponseValue = wasm.TS_PeerDetails_get_is_inbound_connection(this_ptr);
44416 return nativeResponseValue;
44418 // void PeerDetails_set_is_inbound_connection(struct LDKPeerDetails *NONNULL_PTR this_ptr, bool val);
44420 export function PeerDetails_set_is_inbound_connection(this_ptr: bigint, val: boolean): void {
44421 if(!isWasmInitialized) {
44422 throw new Error("initializeWasm() must be awaited first!");
44424 const nativeResponseValue = wasm.TS_PeerDetails_set_is_inbound_connection(this_ptr, val);
44425 // debug statements here
44427 // MUST_USE_RES struct LDKPeerDetails PeerDetails_new(struct LDKPublicKey counterparty_node_id_arg, struct LDKCOption_SocketAddressZ socket_address_arg, struct LDKInitFeatures init_features_arg, bool is_inbound_connection_arg);
44429 export function PeerDetails_new(counterparty_node_id_arg: number, socket_address_arg: bigint, init_features_arg: bigint, is_inbound_connection_arg: boolean): bigint {
44430 if(!isWasmInitialized) {
44431 throw new Error("initializeWasm() must be awaited first!");
44433 const nativeResponseValue = wasm.TS_PeerDetails_new(counterparty_node_id_arg, socket_address_arg, init_features_arg, is_inbound_connection_arg);
44434 return nativeResponseValue;
44436 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
44438 export function PeerHandleError_free(this_obj: bigint): void {
44439 if(!isWasmInitialized) {
44440 throw new Error("initializeWasm() must be awaited first!");
44442 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
44443 // debug statements here
44445 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
44447 export function PeerHandleError_new(): bigint {
44448 if(!isWasmInitialized) {
44449 throw new Error("initializeWasm() must be awaited first!");
44451 const nativeResponseValue = wasm.TS_PeerHandleError_new();
44452 return nativeResponseValue;
44454 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
44456 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
44457 if(!isWasmInitialized) {
44458 throw new Error("initializeWasm() must be awaited first!");
44460 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
44461 return nativeResponseValue;
44463 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
44465 export function PeerHandleError_clone(orig: bigint): bigint {
44466 if(!isWasmInitialized) {
44467 throw new Error("initializeWasm() must be awaited first!");
44469 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
44470 return nativeResponseValue;
44472 // void PeerManager_free(struct LDKPeerManager this_obj);
44474 export function PeerManager_free(this_obj: bigint): void {
44475 if(!isWasmInitialized) {
44476 throw new Error("initializeWasm() must be awaited first!");
44478 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
44479 // debug statements here
44481 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, uint32_t current_time, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKNodeSigner node_signer);
44483 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, node_signer: bigint): bigint {
44484 if(!isWasmInitialized) {
44485 throw new Error("initializeWasm() must be awaited first!");
44487 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, node_signer);
44488 return nativeResponseValue;
44490 // MUST_USE_RES struct LDKCVec_PeerDetailsZ PeerManager_list_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
44492 export function PeerManager_list_peers(this_arg: bigint): number {
44493 if(!isWasmInitialized) {
44494 throw new Error("initializeWasm() must be awaited first!");
44496 const nativeResponseValue = wasm.TS_PeerManager_list_peers(this_arg);
44497 return nativeResponseValue;
44499 // MUST_USE_RES struct LDKPeerDetails PeerManager_peer_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id);
44501 export function PeerManager_peer_by_node_id(this_arg: bigint, their_node_id: number): bigint {
44502 if(!isWasmInitialized) {
44503 throw new Error("initializeWasm() must be awaited first!");
44505 const nativeResponseValue = wasm.TS_PeerManager_peer_by_node_id(this_arg, their_node_id);
44506 return nativeResponseValue;
44508 // 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_SocketAddressZ remote_network_address);
44510 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
44511 if(!isWasmInitialized) {
44512 throw new Error("initializeWasm() must be awaited first!");
44514 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
44515 return nativeResponseValue;
44517 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor, struct LDKCOption_SocketAddressZ remote_network_address);
44519 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
44520 if(!isWasmInitialized) {
44521 throw new Error("initializeWasm() must be awaited first!");
44523 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
44524 return nativeResponseValue;
44526 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
44528 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
44529 if(!isWasmInitialized) {
44530 throw new Error("initializeWasm() must be awaited first!");
44532 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
44533 return nativeResponseValue;
44535 // 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);
44537 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
44538 if(!isWasmInitialized) {
44539 throw new Error("initializeWasm() must be awaited first!");
44541 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
44542 return nativeResponseValue;
44544 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
44546 export function PeerManager_process_events(this_arg: bigint): void {
44547 if(!isWasmInitialized) {
44548 throw new Error("initializeWasm() must be awaited first!");
44550 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
44551 // debug statements here
44553 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
44555 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
44556 if(!isWasmInitialized) {
44557 throw new Error("initializeWasm() must be awaited first!");
44559 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
44560 // debug statements here
44562 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
44564 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
44565 if(!isWasmInitialized) {
44566 throw new Error("initializeWasm() must be awaited first!");
44568 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
44569 // debug statements here
44571 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
44573 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
44574 if(!isWasmInitialized) {
44575 throw new Error("initializeWasm() must be awaited first!");
44577 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
44578 // debug statements here
44580 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
44582 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
44583 if(!isWasmInitialized) {
44584 throw new Error("initializeWasm() must be awaited first!");
44586 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
44587 // debug statements here
44589 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_SocketAddressZ addresses);
44591 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
44592 if(!isWasmInitialized) {
44593 throw new Error("initializeWasm() must be awaited first!");
44595 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
44596 // debug statements here
44598 // uint64_t htlc_success_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
44600 export function htlc_success_tx_weight(channel_type_features: bigint): bigint {
44601 if(!isWasmInitialized) {
44602 throw new Error("initializeWasm() must be awaited first!");
44604 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(channel_type_features);
44605 return nativeResponseValue;
44607 // uint64_t htlc_timeout_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
44609 export function htlc_timeout_tx_weight(channel_type_features: bigint): bigint {
44610 if(!isWasmInitialized) {
44611 throw new Error("initializeWasm() must be awaited first!");
44613 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(channel_type_features);
44614 return nativeResponseValue;
44616 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
44618 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
44619 if(!isWasmInitialized) {
44620 throw new Error("initializeWasm() must be awaited first!");
44622 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
44623 return nativeResponseValue;
44625 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
44627 export function HTLCClaim_offered_timeout(): HTLCClaim {
44628 if(!isWasmInitialized) {
44629 throw new Error("initializeWasm() must be awaited first!");
44631 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
44632 return nativeResponseValue;
44634 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
44636 export function HTLCClaim_offered_preimage(): HTLCClaim {
44637 if(!isWasmInitialized) {
44638 throw new Error("initializeWasm() must be awaited first!");
44640 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
44641 return nativeResponseValue;
44643 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
44645 export function HTLCClaim_accepted_timeout(): HTLCClaim {
44646 if(!isWasmInitialized) {
44647 throw new Error("initializeWasm() must be awaited first!");
44649 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
44650 return nativeResponseValue;
44652 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
44654 export function HTLCClaim_accepted_preimage(): HTLCClaim {
44655 if(!isWasmInitialized) {
44656 throw new Error("initializeWasm() must be awaited first!");
44658 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
44659 return nativeResponseValue;
44661 // enum LDKHTLCClaim HTLCClaim_revocation(void);
44663 export function HTLCClaim_revocation(): HTLCClaim {
44664 if(!isWasmInitialized) {
44665 throw new Error("initializeWasm() must be awaited first!");
44667 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
44668 return nativeResponseValue;
44670 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
44672 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
44673 if(!isWasmInitialized) {
44674 throw new Error("initializeWasm() must be awaited first!");
44676 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
44677 return nativeResponseValue;
44679 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
44681 export function HTLCClaim_from_witness(witness: number): bigint {
44682 if(!isWasmInitialized) {
44683 throw new Error("initializeWasm() must be awaited first!");
44685 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
44686 return nativeResponseValue;
44688 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
44690 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
44691 if(!isWasmInitialized) {
44692 throw new Error("initializeWasm() must be awaited first!");
44694 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
44695 return nativeResponseValue;
44697 // 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);
44699 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 {
44700 if(!isWasmInitialized) {
44701 throw new Error("initializeWasm() must be awaited first!");
44703 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
44704 return nativeResponseValue;
44706 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
44708 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
44709 if(!isWasmInitialized) {
44710 throw new Error("initializeWasm() must be awaited first!");
44712 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
44713 // debug statements here
44715 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
44717 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
44718 if(!isWasmInitialized) {
44719 throw new Error("initializeWasm() must be awaited first!");
44721 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
44722 return nativeResponseValue;
44724 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
44726 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
44727 if(!isWasmInitialized) {
44728 throw new Error("initializeWasm() must be awaited first!");
44730 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
44731 return nativeResponseValue;
44733 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
44735 export function CounterpartyCommitmentSecrets_new(): bigint {
44736 if(!isWasmInitialized) {
44737 throw new Error("initializeWasm() must be awaited first!");
44739 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
44740 return nativeResponseValue;
44742 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
44744 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
44745 if(!isWasmInitialized) {
44746 throw new Error("initializeWasm() must be awaited first!");
44748 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
44749 return nativeResponseValue;
44751 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
44753 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
44754 if(!isWasmInitialized) {
44755 throw new Error("initializeWasm() must be awaited first!");
44757 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
44758 return nativeResponseValue;
44760 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
44762 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
44763 if(!isWasmInitialized) {
44764 throw new Error("initializeWasm() must be awaited first!");
44766 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
44767 return nativeResponseValue;
44769 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
44771 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
44772 if(!isWasmInitialized) {
44773 throw new Error("initializeWasm() must be awaited first!");
44775 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
44776 return nativeResponseValue;
44778 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
44780 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
44781 if(!isWasmInitialized) {
44782 throw new Error("initializeWasm() must be awaited first!");
44784 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
44785 return nativeResponseValue;
44787 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
44789 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
44790 if(!isWasmInitialized) {
44791 throw new Error("initializeWasm() must be awaited first!");
44793 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
44794 return nativeResponseValue;
44796 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
44798 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
44799 if(!isWasmInitialized) {
44800 throw new Error("initializeWasm() must be awaited first!");
44802 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
44803 return nativeResponseValue;
44805 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
44807 export function TxCreationKeys_free(this_obj: bigint): void {
44808 if(!isWasmInitialized) {
44809 throw new Error("initializeWasm() must be awaited first!");
44811 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
44812 // debug statements here
44814 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
44816 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
44817 if(!isWasmInitialized) {
44818 throw new Error("initializeWasm() must be awaited first!");
44820 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
44821 return nativeResponseValue;
44823 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
44825 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
44826 if(!isWasmInitialized) {
44827 throw new Error("initializeWasm() must be awaited first!");
44829 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
44830 // debug statements here
44832 // struct LDKRevocationKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
44834 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): bigint {
44835 if(!isWasmInitialized) {
44836 throw new Error("initializeWasm() must be awaited first!");
44838 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
44839 return nativeResponseValue;
44841 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKRevocationKey val);
44843 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: bigint): void {
44844 if(!isWasmInitialized) {
44845 throw new Error("initializeWasm() must be awaited first!");
44847 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
44848 // debug statements here
44850 // struct LDKHtlcKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
44852 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): bigint {
44853 if(!isWasmInitialized) {
44854 throw new Error("initializeWasm() must be awaited first!");
44856 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
44857 return nativeResponseValue;
44859 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKHtlcKey val);
44861 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: bigint): void {
44862 if(!isWasmInitialized) {
44863 throw new Error("initializeWasm() must be awaited first!");
44865 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
44866 // debug statements here
44868 // struct LDKHtlcKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
44870 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): bigint {
44871 if(!isWasmInitialized) {
44872 throw new Error("initializeWasm() must be awaited first!");
44874 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
44875 return nativeResponseValue;
44877 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKHtlcKey val);
44879 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: bigint): void {
44880 if(!isWasmInitialized) {
44881 throw new Error("initializeWasm() must be awaited first!");
44883 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
44884 // debug statements here
44886 // struct LDKDelayedPaymentKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
44888 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): bigint {
44889 if(!isWasmInitialized) {
44890 throw new Error("initializeWasm() must be awaited first!");
44892 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
44893 return nativeResponseValue;
44895 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKDelayedPaymentKey val);
44897 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: bigint): void {
44898 if(!isWasmInitialized) {
44899 throw new Error("initializeWasm() must be awaited first!");
44901 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
44902 // debug statements here
44904 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_new(struct LDKPublicKey per_commitment_point_arg, struct LDKRevocationKey revocation_key_arg, struct LDKHtlcKey broadcaster_htlc_key_arg, struct LDKHtlcKey countersignatory_htlc_key_arg, struct LDKDelayedPaymentKey broadcaster_delayed_payment_key_arg);
44906 export function TxCreationKeys_new(per_commitment_point_arg: number, revocation_key_arg: bigint, broadcaster_htlc_key_arg: bigint, countersignatory_htlc_key_arg: bigint, broadcaster_delayed_payment_key_arg: bigint): bigint {
44907 if(!isWasmInitialized) {
44908 throw new Error("initializeWasm() must be awaited first!");
44910 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);
44911 return nativeResponseValue;
44913 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
44915 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
44916 if(!isWasmInitialized) {
44917 throw new Error("initializeWasm() must be awaited first!");
44919 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
44920 return nativeResponseValue;
44922 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
44924 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
44925 if(!isWasmInitialized) {
44926 throw new Error("initializeWasm() must be awaited first!");
44928 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
44929 return nativeResponseValue;
44931 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
44933 export function TxCreationKeys_clone(orig: bigint): bigint {
44934 if(!isWasmInitialized) {
44935 throw new Error("initializeWasm() must be awaited first!");
44937 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
44938 return nativeResponseValue;
44940 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
44942 export function TxCreationKeys_write(obj: bigint): number {
44943 if(!isWasmInitialized) {
44944 throw new Error("initializeWasm() must be awaited first!");
44946 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
44947 return nativeResponseValue;
44949 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
44951 export function TxCreationKeys_read(ser: number): bigint {
44952 if(!isWasmInitialized) {
44953 throw new Error("initializeWasm() must be awaited first!");
44955 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
44956 return nativeResponseValue;
44958 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
44960 export function ChannelPublicKeys_free(this_obj: bigint): void {
44961 if(!isWasmInitialized) {
44962 throw new Error("initializeWasm() must be awaited first!");
44964 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
44965 // debug statements here
44967 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
44969 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
44970 if(!isWasmInitialized) {
44971 throw new Error("initializeWasm() must be awaited first!");
44973 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
44974 return nativeResponseValue;
44976 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
44978 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
44979 if(!isWasmInitialized) {
44980 throw new Error("initializeWasm() must be awaited first!");
44982 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
44983 // debug statements here
44985 // struct LDKRevocationBasepoint ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
44987 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): bigint {
44988 if(!isWasmInitialized) {
44989 throw new Error("initializeWasm() must be awaited first!");
44991 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
44992 return nativeResponseValue;
44994 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKRevocationBasepoint val);
44996 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: bigint): void {
44997 if(!isWasmInitialized) {
44998 throw new Error("initializeWasm() must be awaited first!");
45000 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
45001 // debug statements here
45003 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
45005 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
45006 if(!isWasmInitialized) {
45007 throw new Error("initializeWasm() must be awaited first!");
45009 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
45010 return nativeResponseValue;
45012 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
45014 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
45015 if(!isWasmInitialized) {
45016 throw new Error("initializeWasm() must be awaited first!");
45018 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
45019 // debug statements here
45021 // struct LDKDelayedPaymentBasepoint ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
45023 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): bigint {
45024 if(!isWasmInitialized) {
45025 throw new Error("initializeWasm() must be awaited first!");
45027 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
45028 return nativeResponseValue;
45030 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKDelayedPaymentBasepoint val);
45032 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: bigint): void {
45033 if(!isWasmInitialized) {
45034 throw new Error("initializeWasm() must be awaited first!");
45036 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
45037 // debug statements here
45039 // struct LDKHtlcBasepoint ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
45041 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): bigint {
45042 if(!isWasmInitialized) {
45043 throw new Error("initializeWasm() must be awaited first!");
45045 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
45046 return nativeResponseValue;
45048 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKHtlcBasepoint val);
45050 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: bigint): void {
45051 if(!isWasmInitialized) {
45052 throw new Error("initializeWasm() must be awaited first!");
45054 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
45055 // debug statements here
45057 // MUST_USE_RES struct LDKChannelPublicKeys ChannelPublicKeys_new(struct LDKPublicKey funding_pubkey_arg, struct LDKRevocationBasepoint revocation_basepoint_arg, struct LDKPublicKey payment_point_arg, struct LDKDelayedPaymentBasepoint delayed_payment_basepoint_arg, struct LDKHtlcBasepoint htlc_basepoint_arg);
45059 export function ChannelPublicKeys_new(funding_pubkey_arg: number, revocation_basepoint_arg: bigint, payment_point_arg: number, delayed_payment_basepoint_arg: bigint, htlc_basepoint_arg: bigint): bigint {
45060 if(!isWasmInitialized) {
45061 throw new Error("initializeWasm() must be awaited first!");
45063 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
45064 return nativeResponseValue;
45066 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
45068 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
45069 if(!isWasmInitialized) {
45070 throw new Error("initializeWasm() must be awaited first!");
45072 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
45073 return nativeResponseValue;
45075 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
45077 export function ChannelPublicKeys_clone(orig: bigint): bigint {
45078 if(!isWasmInitialized) {
45079 throw new Error("initializeWasm() must be awaited first!");
45081 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
45082 return nativeResponseValue;
45084 // uint64_t ChannelPublicKeys_hash(const struct LDKChannelPublicKeys *NONNULL_PTR o);
45086 export function ChannelPublicKeys_hash(o: bigint): bigint {
45087 if(!isWasmInitialized) {
45088 throw new Error("initializeWasm() must be awaited first!");
45090 const nativeResponseValue = wasm.TS_ChannelPublicKeys_hash(o);
45091 return nativeResponseValue;
45093 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
45095 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
45096 if(!isWasmInitialized) {
45097 throw new Error("initializeWasm() must be awaited first!");
45099 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
45100 return nativeResponseValue;
45102 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
45104 export function ChannelPublicKeys_write(obj: bigint): number {
45105 if(!isWasmInitialized) {
45106 throw new Error("initializeWasm() must be awaited first!");
45108 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
45109 return nativeResponseValue;
45111 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
45113 export function ChannelPublicKeys_read(ser: number): bigint {
45114 if(!isWasmInitialized) {
45115 throw new Error("initializeWasm() must be awaited first!");
45117 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
45118 return nativeResponseValue;
45120 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR broadcaster_delayed_payment_base, const struct LDKHtlcBasepoint *NONNULL_PTR broadcaster_htlc_base, const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_revocation_base, const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_htlc_base);
45122 export function TxCreationKeys_derive_new(per_commitment_point: number, broadcaster_delayed_payment_base: bigint, broadcaster_htlc_base: bigint, countersignatory_revocation_base: bigint, countersignatory_htlc_base: bigint): bigint {
45123 if(!isWasmInitialized) {
45124 throw new Error("initializeWasm() must be awaited first!");
45126 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
45127 return nativeResponseValue;
45129 // 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);
45131 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
45132 if(!isWasmInitialized) {
45133 throw new Error("initializeWasm() must be awaited first!");
45135 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
45136 return nativeResponseValue;
45138 // struct LDKCVec_u8Z get_revokeable_redeemscript(const struct LDKRevocationKey *NONNULL_PTR revocation_key, uint16_t contest_delay, const struct LDKDelayedPaymentKey *NONNULL_PTR broadcaster_delayed_payment_key);
45140 export function get_revokeable_redeemscript(revocation_key: bigint, contest_delay: number, broadcaster_delayed_payment_key: bigint): number {
45141 if(!isWasmInitialized) {
45142 throw new Error("initializeWasm() must be awaited first!");
45144 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
45145 return nativeResponseValue;
45147 // struct LDKCVec_u8Z get_counterparty_payment_script(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, struct LDKPublicKey payment_key);
45149 export function get_counterparty_payment_script(channel_type_features: bigint, payment_key: number): number {
45150 if(!isWasmInitialized) {
45151 throw new Error("initializeWasm() must be awaited first!");
45153 const nativeResponseValue = wasm.TS_get_counterparty_payment_script(channel_type_features, payment_key);
45154 return nativeResponseValue;
45156 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
45158 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
45159 if(!isWasmInitialized) {
45160 throw new Error("initializeWasm() must be awaited first!");
45162 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
45163 // debug statements here
45165 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
45167 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
45168 if(!isWasmInitialized) {
45169 throw new Error("initializeWasm() must be awaited first!");
45171 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
45172 return nativeResponseValue;
45174 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
45176 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
45177 if(!isWasmInitialized) {
45178 throw new Error("initializeWasm() must be awaited first!");
45180 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
45181 // debug statements here
45183 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
45185 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
45186 if(!isWasmInitialized) {
45187 throw new Error("initializeWasm() must be awaited first!");
45189 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
45190 return nativeResponseValue;
45192 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
45194 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
45195 if(!isWasmInitialized) {
45196 throw new Error("initializeWasm() must be awaited first!");
45198 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
45199 // debug statements here
45201 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
45203 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
45204 if(!isWasmInitialized) {
45205 throw new Error("initializeWasm() must be awaited first!");
45207 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
45208 return nativeResponseValue;
45210 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
45212 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
45213 if(!isWasmInitialized) {
45214 throw new Error("initializeWasm() must be awaited first!");
45216 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
45217 // debug statements here
45219 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
45221 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
45222 if(!isWasmInitialized) {
45223 throw new Error("initializeWasm() must be awaited first!");
45225 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
45226 return nativeResponseValue;
45228 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
45230 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
45231 if(!isWasmInitialized) {
45232 throw new Error("initializeWasm() must be awaited first!");
45234 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
45235 // debug statements here
45237 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
45239 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
45240 if(!isWasmInitialized) {
45241 throw new Error("initializeWasm() must be awaited first!");
45243 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
45244 return nativeResponseValue;
45246 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
45248 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
45249 if(!isWasmInitialized) {
45250 throw new Error("initializeWasm() must be awaited first!");
45252 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
45253 // debug statements here
45255 // 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);
45257 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 {
45258 if(!isWasmInitialized) {
45259 throw new Error("initializeWasm() must be awaited first!");
45261 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
45262 return nativeResponseValue;
45264 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
45266 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
45267 if(!isWasmInitialized) {
45268 throw new Error("initializeWasm() must be awaited first!");
45270 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
45271 return nativeResponseValue;
45273 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
45275 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
45276 if(!isWasmInitialized) {
45277 throw new Error("initializeWasm() must be awaited first!");
45279 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
45280 return nativeResponseValue;
45282 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
45284 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
45285 if(!isWasmInitialized) {
45286 throw new Error("initializeWasm() must be awaited first!");
45288 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
45289 return nativeResponseValue;
45291 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
45293 export function HTLCOutputInCommitment_write(obj: bigint): number {
45294 if(!isWasmInitialized) {
45295 throw new Error("initializeWasm() must be awaited first!");
45297 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
45298 return nativeResponseValue;
45300 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
45302 export function HTLCOutputInCommitment_read(ser: number): bigint {
45303 if(!isWasmInitialized) {
45304 throw new Error("initializeWasm() must be awaited first!");
45306 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
45307 return nativeResponseValue;
45309 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, const struct LDKTxCreationKeys *NONNULL_PTR keys);
45311 export function get_htlc_redeemscript(htlc: bigint, channel_type_features: bigint, keys: bigint): number {
45312 if(!isWasmInitialized) {
45313 throw new Error("initializeWasm() must be awaited first!");
45315 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, channel_type_features, keys);
45316 return nativeResponseValue;
45318 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
45320 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
45321 if(!isWasmInitialized) {
45322 throw new Error("initializeWasm() must be awaited first!");
45324 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
45325 return nativeResponseValue;
45327 // 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, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, const struct LDKDelayedPaymentKey *NONNULL_PTR broadcaster_delayed_payment_key, const struct LDKRevocationKey *NONNULL_PTR revocation_key);
45329 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, channel_type_features: bigint, broadcaster_delayed_payment_key: bigint, revocation_key: bigint): number {
45330 if(!isWasmInitialized) {
45331 throw new Error("initializeWasm() must be awaited first!");
45333 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, channel_type_features, broadcaster_delayed_payment_key, revocation_key);
45334 return nativeResponseValue;
45336 // struct LDKWitness build_htlc_input_witness(struct LDKECDSASignature local_sig, struct LDKECDSASignature remote_sig, struct LDKCOption_ThirtyTwoBytesZ preimage, struct LDKu8slice redeem_script, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
45338 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: bigint, redeem_script: number, channel_type_features: bigint): number {
45339 if(!isWasmInitialized) {
45340 throw new Error("initializeWasm() must be awaited first!");
45342 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, channel_type_features);
45343 return nativeResponseValue;
45345 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
45347 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
45348 if(!isWasmInitialized) {
45349 throw new Error("initializeWasm() must be awaited first!");
45351 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
45352 return nativeResponseValue;
45354 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
45356 export function get_anchor_redeemscript(funding_pubkey: number): number {
45357 if(!isWasmInitialized) {
45358 throw new Error("initializeWasm() must be awaited first!");
45360 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
45361 return nativeResponseValue;
45363 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKECDSASignature funding_sig);
45365 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
45366 if(!isWasmInitialized) {
45367 throw new Error("initializeWasm() must be awaited first!");
45369 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
45370 return nativeResponseValue;
45372 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
45374 export function ChannelTransactionParameters_free(this_obj: bigint): void {
45375 if(!isWasmInitialized) {
45376 throw new Error("initializeWasm() must be awaited first!");
45378 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
45379 // debug statements here
45381 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45383 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
45384 if(!isWasmInitialized) {
45385 throw new Error("initializeWasm() must be awaited first!");
45387 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
45388 return nativeResponseValue;
45390 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
45392 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
45393 if(!isWasmInitialized) {
45394 throw new Error("initializeWasm() must be awaited first!");
45396 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
45397 // debug statements here
45399 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45401 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
45402 if(!isWasmInitialized) {
45403 throw new Error("initializeWasm() must be awaited first!");
45405 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
45406 return nativeResponseValue;
45408 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
45410 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
45411 if(!isWasmInitialized) {
45412 throw new Error("initializeWasm() must be awaited first!");
45414 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
45415 // debug statements here
45417 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45419 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
45420 if(!isWasmInitialized) {
45421 throw new Error("initializeWasm() must be awaited first!");
45423 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
45424 return nativeResponseValue;
45426 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
45428 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
45429 if(!isWasmInitialized) {
45430 throw new Error("initializeWasm() must be awaited first!");
45432 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
45433 // debug statements here
45435 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45437 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
45438 if(!isWasmInitialized) {
45439 throw new Error("initializeWasm() must be awaited first!");
45441 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
45442 return nativeResponseValue;
45444 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
45446 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
45447 if(!isWasmInitialized) {
45448 throw new Error("initializeWasm() must be awaited first!");
45450 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
45451 // debug statements here
45453 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45455 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
45456 if(!isWasmInitialized) {
45457 throw new Error("initializeWasm() must be awaited first!");
45459 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
45460 return nativeResponseValue;
45462 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
45464 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
45465 if(!isWasmInitialized) {
45466 throw new Error("initializeWasm() must be awaited first!");
45468 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
45469 // debug statements here
45471 // struct LDKChannelTypeFeatures ChannelTransactionParameters_get_channel_type_features(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
45473 export function ChannelTransactionParameters_get_channel_type_features(this_ptr: bigint): bigint {
45474 if(!isWasmInitialized) {
45475 throw new Error("initializeWasm() must be awaited first!");
45477 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_channel_type_features(this_ptr);
45478 return nativeResponseValue;
45480 // void ChannelTransactionParameters_set_channel_type_features(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
45482 export function ChannelTransactionParameters_set_channel_type_features(this_ptr: bigint, val: bigint): void {
45483 if(!isWasmInitialized) {
45484 throw new Error("initializeWasm() must be awaited first!");
45486 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_channel_type_features(this_ptr, val);
45487 // debug statements here
45489 // 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, struct LDKChannelTypeFeatures channel_type_features_arg);
45491 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, channel_type_features_arg: bigint): bigint {
45492 if(!isWasmInitialized) {
45493 throw new Error("initializeWasm() must be awaited first!");
45495 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, channel_type_features_arg);
45496 return nativeResponseValue;
45498 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
45500 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
45501 if(!isWasmInitialized) {
45502 throw new Error("initializeWasm() must be awaited first!");
45504 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
45505 return nativeResponseValue;
45507 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
45509 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
45510 if(!isWasmInitialized) {
45511 throw new Error("initializeWasm() must be awaited first!");
45513 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
45514 return nativeResponseValue;
45516 // uint64_t ChannelTransactionParameters_hash(const struct LDKChannelTransactionParameters *NONNULL_PTR o);
45518 export function ChannelTransactionParameters_hash(o: bigint): bigint {
45519 if(!isWasmInitialized) {
45520 throw new Error("initializeWasm() must be awaited first!");
45522 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_hash(o);
45523 return nativeResponseValue;
45525 // bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
45527 export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
45528 if(!isWasmInitialized) {
45529 throw new Error("initializeWasm() must be awaited first!");
45531 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
45532 return nativeResponseValue;
45534 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
45536 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
45537 if(!isWasmInitialized) {
45538 throw new Error("initializeWasm() must be awaited first!");
45540 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
45541 // debug statements here
45543 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
45545 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
45546 if(!isWasmInitialized) {
45547 throw new Error("initializeWasm() must be awaited first!");
45549 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
45550 return nativeResponseValue;
45552 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
45554 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
45555 if(!isWasmInitialized) {
45556 throw new Error("initializeWasm() must be awaited first!");
45558 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
45559 // debug statements here
45561 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
45563 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
45564 if(!isWasmInitialized) {
45565 throw new Error("initializeWasm() must be awaited first!");
45567 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
45568 return nativeResponseValue;
45570 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
45572 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
45573 if(!isWasmInitialized) {
45574 throw new Error("initializeWasm() must be awaited first!");
45576 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
45577 // debug statements here
45579 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
45581 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
45582 if(!isWasmInitialized) {
45583 throw new Error("initializeWasm() must be awaited first!");
45585 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
45586 return nativeResponseValue;
45588 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
45590 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
45591 if(!isWasmInitialized) {
45592 throw new Error("initializeWasm() must be awaited first!");
45594 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
45595 return nativeResponseValue;
45597 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
45599 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
45600 if(!isWasmInitialized) {
45601 throw new Error("initializeWasm() must be awaited first!");
45603 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
45604 return nativeResponseValue;
45606 // uint64_t CounterpartyChannelTransactionParameters_hash(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR o);
45608 export function CounterpartyChannelTransactionParameters_hash(o: bigint): bigint {
45609 if(!isWasmInitialized) {
45610 throw new Error("initializeWasm() must be awaited first!");
45612 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_hash(o);
45613 return nativeResponseValue;
45615 // bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
45617 export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
45618 if(!isWasmInitialized) {
45619 throw new Error("initializeWasm() must be awaited first!");
45621 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
45622 return nativeResponseValue;
45624 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
45626 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
45627 if(!isWasmInitialized) {
45628 throw new Error("initializeWasm() must be awaited first!");
45630 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
45631 return nativeResponseValue;
45633 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
45635 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
45636 if(!isWasmInitialized) {
45637 throw new Error("initializeWasm() must be awaited first!");
45639 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
45640 return nativeResponseValue;
45642 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
45644 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
45645 if(!isWasmInitialized) {
45646 throw new Error("initializeWasm() must be awaited first!");
45648 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
45649 return nativeResponseValue;
45651 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
45653 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
45654 if(!isWasmInitialized) {
45655 throw new Error("initializeWasm() must be awaited first!");
45657 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
45658 return nativeResponseValue;
45660 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
45662 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
45663 if(!isWasmInitialized) {
45664 throw new Error("initializeWasm() must be awaited first!");
45666 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
45667 return nativeResponseValue;
45669 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
45671 export function ChannelTransactionParameters_write(obj: bigint): number {
45672 if(!isWasmInitialized) {
45673 throw new Error("initializeWasm() must be awaited first!");
45675 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
45676 return nativeResponseValue;
45678 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
45680 export function ChannelTransactionParameters_read(ser: number): bigint {
45681 if(!isWasmInitialized) {
45682 throw new Error("initializeWasm() must be awaited first!");
45684 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
45685 return nativeResponseValue;
45687 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
45689 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
45690 if(!isWasmInitialized) {
45691 throw new Error("initializeWasm() must be awaited first!");
45693 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
45694 // debug statements here
45696 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45698 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
45699 if(!isWasmInitialized) {
45700 throw new Error("initializeWasm() must be awaited first!");
45702 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
45703 return nativeResponseValue;
45705 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45707 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
45708 if(!isWasmInitialized) {
45709 throw new Error("initializeWasm() must be awaited first!");
45711 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
45712 return nativeResponseValue;
45714 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45716 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
45717 if(!isWasmInitialized) {
45718 throw new Error("initializeWasm() must be awaited first!");
45720 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
45721 return nativeResponseValue;
45723 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45725 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
45726 if(!isWasmInitialized) {
45727 throw new Error("initializeWasm() must be awaited first!");
45729 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
45730 return nativeResponseValue;
45732 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45734 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
45735 if(!isWasmInitialized) {
45736 throw new Error("initializeWasm() must be awaited first!");
45738 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
45739 return nativeResponseValue;
45741 // MUST_USE_RES struct LDKChannelTypeFeatures DirectedChannelTransactionParameters_channel_type_features(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
45743 export function DirectedChannelTransactionParameters_channel_type_features(this_arg: bigint): bigint {
45744 if(!isWasmInitialized) {
45745 throw new Error("initializeWasm() must be awaited first!");
45747 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_channel_type_features(this_arg);
45748 return nativeResponseValue;
45750 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
45752 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
45753 if(!isWasmInitialized) {
45754 throw new Error("initializeWasm() must be awaited first!");
45756 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
45757 // debug statements here
45759 // struct LDKECDSASignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
45761 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
45762 if(!isWasmInitialized) {
45763 throw new Error("initializeWasm() must be awaited first!");
45765 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
45766 return nativeResponseValue;
45768 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
45770 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
45771 if(!isWasmInitialized) {
45772 throw new Error("initializeWasm() must be awaited first!");
45774 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
45775 // debug statements here
45777 // struct LDKCVec_ECDSASignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
45779 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
45780 if(!isWasmInitialized) {
45781 throw new Error("initializeWasm() must be awaited first!");
45783 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
45784 return nativeResponseValue;
45786 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
45788 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
45789 if(!isWasmInitialized) {
45790 throw new Error("initializeWasm() must be awaited first!");
45792 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
45793 // debug statements here
45795 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
45797 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
45798 if(!isWasmInitialized) {
45799 throw new Error("initializeWasm() must be awaited first!");
45801 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
45802 return nativeResponseValue;
45804 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
45806 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
45807 if(!isWasmInitialized) {
45808 throw new Error("initializeWasm() must be awaited first!");
45810 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
45811 return nativeResponseValue;
45813 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
45815 export function HolderCommitmentTransaction_write(obj: bigint): number {
45816 if(!isWasmInitialized) {
45817 throw new Error("initializeWasm() must be awaited first!");
45819 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
45820 return nativeResponseValue;
45822 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
45824 export function HolderCommitmentTransaction_read(ser: number): bigint {
45825 if(!isWasmInitialized) {
45826 throw new Error("initializeWasm() must be awaited first!");
45828 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
45829 return nativeResponseValue;
45831 // MUST_USE_RES struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_new(struct LDKCommitmentTransaction commitment_tx, struct LDKECDSASignature counterparty_sig, struct LDKCVec_ECDSASignatureZ counterparty_htlc_sigs, struct LDKPublicKey holder_funding_key, struct LDKPublicKey counterparty_funding_key);
45833 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
45834 if(!isWasmInitialized) {
45835 throw new Error("initializeWasm() must be awaited first!");
45837 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
45838 return nativeResponseValue;
45840 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
45842 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
45843 if(!isWasmInitialized) {
45844 throw new Error("initializeWasm() must be awaited first!");
45846 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
45847 // debug statements here
45849 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
45851 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
45852 if(!isWasmInitialized) {
45853 throw new Error("initializeWasm() must be awaited first!");
45855 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
45856 return nativeResponseValue;
45858 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
45860 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
45861 if(!isWasmInitialized) {
45862 throw new Error("initializeWasm() must be awaited first!");
45864 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
45865 // debug statements here
45867 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
45869 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
45870 if(!isWasmInitialized) {
45871 throw new Error("initializeWasm() must be awaited first!");
45873 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
45874 return nativeResponseValue;
45876 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
45878 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
45879 if(!isWasmInitialized) {
45880 throw new Error("initializeWasm() must be awaited first!");
45882 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
45883 // debug statements here
45885 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
45887 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
45888 if(!isWasmInitialized) {
45889 throw new Error("initializeWasm() must be awaited first!");
45891 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
45892 return nativeResponseValue;
45894 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
45896 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
45897 if(!isWasmInitialized) {
45898 throw new Error("initializeWasm() must be awaited first!");
45900 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
45901 return nativeResponseValue;
45903 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
45905 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
45906 if(!isWasmInitialized) {
45907 throw new Error("initializeWasm() must be awaited first!");
45909 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
45910 return nativeResponseValue;
45912 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
45914 export function BuiltCommitmentTransaction_write(obj: bigint): number {
45915 if(!isWasmInitialized) {
45916 throw new Error("initializeWasm() must be awaited first!");
45918 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
45919 return nativeResponseValue;
45921 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
45923 export function BuiltCommitmentTransaction_read(ser: number): bigint {
45924 if(!isWasmInitialized) {
45925 throw new Error("initializeWasm() must be awaited first!");
45927 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
45928 return nativeResponseValue;
45930 // 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);
45932 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
45933 if(!isWasmInitialized) {
45934 throw new Error("initializeWasm() must be awaited first!");
45936 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
45937 return nativeResponseValue;
45939 // MUST_USE_RES struct LDKECDSASignature BuiltCommitmentTransaction_sign_counterparty_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
45941 export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
45942 if(!isWasmInitialized) {
45943 throw new Error("initializeWasm() must be awaited first!");
45945 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
45946 return nativeResponseValue;
45948 // MUST_USE_RES struct LDKECDSASignature BuiltCommitmentTransaction_sign_holder_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis, const struct LDKEntropySource *NONNULL_PTR entropy_source);
45950 export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
45951 if(!isWasmInitialized) {
45952 throw new Error("initializeWasm() must be awaited first!");
45954 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
45955 return nativeResponseValue;
45957 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
45959 export function ClosingTransaction_free(this_obj: bigint): void {
45960 if(!isWasmInitialized) {
45961 throw new Error("initializeWasm() must be awaited first!");
45963 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
45964 // debug statements here
45966 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
45968 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
45969 if(!isWasmInitialized) {
45970 throw new Error("initializeWasm() must be awaited first!");
45972 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
45973 return nativeResponseValue;
45975 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
45977 export function ClosingTransaction_clone(orig: bigint): bigint {
45978 if(!isWasmInitialized) {
45979 throw new Error("initializeWasm() must be awaited first!");
45981 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
45982 return nativeResponseValue;
45984 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
45986 export function ClosingTransaction_hash(o: bigint): bigint {
45987 if(!isWasmInitialized) {
45988 throw new Error("initializeWasm() must be awaited first!");
45990 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
45991 return nativeResponseValue;
45993 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
45995 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
45996 if(!isWasmInitialized) {
45997 throw new Error("initializeWasm() must be awaited first!");
45999 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
46000 return nativeResponseValue;
46002 // 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);
46004 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 {
46005 if(!isWasmInitialized) {
46006 throw new Error("initializeWasm() must be awaited first!");
46008 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
46009 return nativeResponseValue;
46011 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
46013 export function ClosingTransaction_trust(this_arg: bigint): bigint {
46014 if(!isWasmInitialized) {
46015 throw new Error("initializeWasm() must be awaited first!");
46017 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
46018 return nativeResponseValue;
46020 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
46022 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
46023 if(!isWasmInitialized) {
46024 throw new Error("initializeWasm() must be awaited first!");
46026 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
46027 return nativeResponseValue;
46029 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
46031 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
46032 if(!isWasmInitialized) {
46033 throw new Error("initializeWasm() must be awaited first!");
46035 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
46036 return nativeResponseValue;
46038 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
46040 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
46041 if(!isWasmInitialized) {
46042 throw new Error("initializeWasm() must be awaited first!");
46044 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
46045 return nativeResponseValue;
46047 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
46049 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
46050 if(!isWasmInitialized) {
46051 throw new Error("initializeWasm() must be awaited first!");
46053 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
46054 return nativeResponseValue;
46056 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
46058 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
46059 if(!isWasmInitialized) {
46060 throw new Error("initializeWasm() must be awaited first!");
46062 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
46063 return nativeResponseValue;
46065 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
46067 export function TrustedClosingTransaction_free(this_obj: bigint): void {
46068 if(!isWasmInitialized) {
46069 throw new Error("initializeWasm() must be awaited first!");
46071 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
46072 // debug statements here
46074 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
46076 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
46077 if(!isWasmInitialized) {
46078 throw new Error("initializeWasm() must be awaited first!");
46080 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
46081 return nativeResponseValue;
46083 // 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);
46085 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
46086 if(!isWasmInitialized) {
46087 throw new Error("initializeWasm() must be awaited first!");
46089 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
46090 return nativeResponseValue;
46092 // MUST_USE_RES struct LDKECDSASignature TrustedClosingTransaction_sign(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
46094 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
46095 if(!isWasmInitialized) {
46096 throw new Error("initializeWasm() must be awaited first!");
46098 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
46099 return nativeResponseValue;
46101 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
46103 export function CommitmentTransaction_free(this_obj: bigint): void {
46104 if(!isWasmInitialized) {
46105 throw new Error("initializeWasm() must be awaited first!");
46107 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
46108 // debug statements here
46110 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
46112 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
46113 if(!isWasmInitialized) {
46114 throw new Error("initializeWasm() must be awaited first!");
46116 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
46117 return nativeResponseValue;
46119 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
46121 export function CommitmentTransaction_clone(orig: bigint): bigint {
46122 if(!isWasmInitialized) {
46123 throw new Error("initializeWasm() must be awaited first!");
46125 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
46126 return nativeResponseValue;
46128 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
46130 export function CommitmentTransaction_write(obj: bigint): number {
46131 if(!isWasmInitialized) {
46132 throw new Error("initializeWasm() must be awaited first!");
46134 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
46135 return nativeResponseValue;
46137 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
46139 export function CommitmentTransaction_read(ser: number): bigint {
46140 if(!isWasmInitialized) {
46141 throw new Error("initializeWasm() must be awaited first!");
46143 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
46144 return nativeResponseValue;
46146 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46148 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
46149 if(!isWasmInitialized) {
46150 throw new Error("initializeWasm() must be awaited first!");
46152 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
46153 return nativeResponseValue;
46155 // MUST_USE_RES struct LDKPublicKey CommitmentTransaction_per_commitment_point(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46157 export function CommitmentTransaction_per_commitment_point(this_arg: bigint): number {
46158 if(!isWasmInitialized) {
46159 throw new Error("initializeWasm() must be awaited first!");
46161 const nativeResponseValue = wasm.TS_CommitmentTransaction_per_commitment_point(this_arg);
46162 return nativeResponseValue;
46164 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46166 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
46167 if(!isWasmInitialized) {
46168 throw new Error("initializeWasm() must be awaited first!");
46170 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
46171 return nativeResponseValue;
46173 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46175 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
46176 if(!isWasmInitialized) {
46177 throw new Error("initializeWasm() must be awaited first!");
46179 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
46180 return nativeResponseValue;
46182 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46184 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
46185 if(!isWasmInitialized) {
46186 throw new Error("initializeWasm() must be awaited first!");
46188 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
46189 return nativeResponseValue;
46191 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
46193 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
46194 if(!isWasmInitialized) {
46195 throw new Error("initializeWasm() must be awaited first!");
46197 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
46198 return nativeResponseValue;
46200 // 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);
46202 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
46203 if(!isWasmInitialized) {
46204 throw new Error("initializeWasm() must be awaited first!");
46206 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
46207 return nativeResponseValue;
46209 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
46211 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
46212 if(!isWasmInitialized) {
46213 throw new Error("initializeWasm() must be awaited first!");
46215 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
46216 // debug statements here
46218 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
46220 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
46221 if(!isWasmInitialized) {
46222 throw new Error("initializeWasm() must be awaited first!");
46224 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
46225 return nativeResponseValue;
46227 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
46229 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
46230 if(!isWasmInitialized) {
46231 throw new Error("initializeWasm() must be awaited first!");
46233 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
46234 return nativeResponseValue;
46236 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
46238 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
46239 if(!isWasmInitialized) {
46240 throw new Error("initializeWasm() must be awaited first!");
46242 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
46243 return nativeResponseValue;
46245 // MUST_USE_RES struct LDKChannelTypeFeatures TrustedCommitmentTransaction_channel_type_features(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
46247 export function TrustedCommitmentTransaction_channel_type_features(this_arg: bigint): bigint {
46248 if(!isWasmInitialized) {
46249 throw new Error("initializeWasm() must be awaited first!");
46251 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_channel_type_features(this_arg);
46252 return nativeResponseValue;
46254 // MUST_USE_RES struct LDKCResult_CVec_ECDSASignatureZNoneZ 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, const struct LDKEntropySource *NONNULL_PTR entropy_source);
46256 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
46257 if(!isWasmInitialized) {
46258 throw new Error("initializeWasm() must be awaited first!");
46260 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
46261 return nativeResponseValue;
46263 // MUST_USE_RES struct LDKCOption_usizeZ TrustedCommitmentTransaction_revokeable_output_index(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
46265 export function TrustedCommitmentTransaction_revokeable_output_index(this_arg: bigint): bigint {
46266 if(!isWasmInitialized) {
46267 throw new Error("initializeWasm() must be awaited first!");
46269 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_revokeable_output_index(this_arg);
46270 return nativeResponseValue;
46272 // MUST_USE_RES struct LDKCResult_TransactionNoneZ TrustedCommitmentTransaction_build_to_local_justice_tx(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, uint64_t feerate_per_kw, struct LDKCVec_u8Z destination_script);
46274 export function TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg: bigint, feerate_per_kw: bigint, destination_script: number): bigint {
46275 if(!isWasmInitialized) {
46276 throw new Error("initializeWasm() must be awaited first!");
46278 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg, feerate_per_kw, destination_script);
46279 return nativeResponseValue;
46281 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
46283 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
46284 if(!isWasmInitialized) {
46285 throw new Error("initializeWasm() must be awaited first!");
46287 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
46288 return nativeResponseValue;
46290 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
46292 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
46293 if(!isWasmInitialized) {
46294 throw new Error("initializeWasm() must be awaited first!");
46296 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
46297 return nativeResponseValue;
46299 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
46301 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
46302 if(!isWasmInitialized) {
46303 throw new Error("initializeWasm() must be awaited first!");
46305 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
46306 return nativeResponseValue;
46308 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
46310 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
46311 if(!isWasmInitialized) {
46312 throw new Error("initializeWasm() must be awaited first!");
46314 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
46315 return nativeResponseValue;
46317 // bool Bolt11InvoiceFeatures_eq(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR b);
46319 export function Bolt11InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
46320 if(!isWasmInitialized) {
46321 throw new Error("initializeWasm() must be awaited first!");
46323 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_eq(a, b);
46324 return nativeResponseValue;
46326 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
46328 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
46329 if(!isWasmInitialized) {
46330 throw new Error("initializeWasm() must be awaited first!");
46332 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
46333 return nativeResponseValue;
46335 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
46337 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
46338 if(!isWasmInitialized) {
46339 throw new Error("initializeWasm() must be awaited first!");
46341 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
46342 return nativeResponseValue;
46344 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
46346 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
46347 if(!isWasmInitialized) {
46348 throw new Error("initializeWasm() must be awaited first!");
46350 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
46351 return nativeResponseValue;
46353 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
46355 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
46356 if(!isWasmInitialized) {
46357 throw new Error("initializeWasm() must be awaited first!");
46359 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
46360 return nativeResponseValue;
46362 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
46364 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
46365 if(!isWasmInitialized) {
46366 throw new Error("initializeWasm() must be awaited first!");
46368 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
46369 return nativeResponseValue;
46371 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
46373 export function InitFeatures_clone_ptr(arg: bigint): bigint {
46374 if(!isWasmInitialized) {
46375 throw new Error("initializeWasm() must be awaited first!");
46377 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
46378 return nativeResponseValue;
46380 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
46382 export function InitFeatures_clone(orig: bigint): bigint {
46383 if(!isWasmInitialized) {
46384 throw new Error("initializeWasm() must be awaited first!");
46386 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
46387 return nativeResponseValue;
46389 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
46391 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
46392 if(!isWasmInitialized) {
46393 throw new Error("initializeWasm() must be awaited first!");
46395 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
46396 return nativeResponseValue;
46398 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
46400 export function NodeFeatures_clone(orig: bigint): bigint {
46401 if(!isWasmInitialized) {
46402 throw new Error("initializeWasm() must be awaited first!");
46404 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
46405 return nativeResponseValue;
46407 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
46409 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
46410 if(!isWasmInitialized) {
46411 throw new Error("initializeWasm() must be awaited first!");
46413 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
46414 return nativeResponseValue;
46416 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
46418 export function ChannelFeatures_clone(orig: bigint): bigint {
46419 if(!isWasmInitialized) {
46420 throw new Error("initializeWasm() must be awaited first!");
46422 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
46423 return nativeResponseValue;
46425 // uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg);
46427 export function Bolt11InvoiceFeatures_clone_ptr(arg: bigint): bigint {
46428 if(!isWasmInitialized) {
46429 throw new Error("initializeWasm() must be awaited first!");
46431 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone_ptr(arg);
46432 return nativeResponseValue;
46434 // struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_clone(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR orig);
46436 export function Bolt11InvoiceFeatures_clone(orig: bigint): bigint {
46437 if(!isWasmInitialized) {
46438 throw new Error("initializeWasm() must be awaited first!");
46440 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone(orig);
46441 return nativeResponseValue;
46443 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
46445 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
46446 if(!isWasmInitialized) {
46447 throw new Error("initializeWasm() must be awaited first!");
46449 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
46450 return nativeResponseValue;
46452 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
46454 export function OfferFeatures_clone(orig: bigint): bigint {
46455 if(!isWasmInitialized) {
46456 throw new Error("initializeWasm() must be awaited first!");
46458 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
46459 return nativeResponseValue;
46461 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
46463 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
46464 if(!isWasmInitialized) {
46465 throw new Error("initializeWasm() must be awaited first!");
46467 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
46468 return nativeResponseValue;
46470 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
46472 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
46473 if(!isWasmInitialized) {
46474 throw new Error("initializeWasm() must be awaited first!");
46476 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
46477 return nativeResponseValue;
46479 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
46481 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
46482 if(!isWasmInitialized) {
46483 throw new Error("initializeWasm() must be awaited first!");
46485 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
46486 return nativeResponseValue;
46488 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
46490 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
46491 if(!isWasmInitialized) {
46492 throw new Error("initializeWasm() must be awaited first!");
46494 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
46495 return nativeResponseValue;
46497 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
46499 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
46500 if(!isWasmInitialized) {
46501 throw new Error("initializeWasm() must be awaited first!");
46503 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
46504 return nativeResponseValue;
46506 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
46508 export function BlindedHopFeatures_clone(orig: bigint): bigint {
46509 if(!isWasmInitialized) {
46510 throw new Error("initializeWasm() must be awaited first!");
46512 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
46513 return nativeResponseValue;
46515 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
46517 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
46518 if(!isWasmInitialized) {
46519 throw new Error("initializeWasm() must be awaited first!");
46521 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
46522 return nativeResponseValue;
46524 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
46526 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
46527 if(!isWasmInitialized) {
46528 throw new Error("initializeWasm() must be awaited first!");
46530 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
46531 return nativeResponseValue;
46533 // uint64_t InitFeatures_hash(const struct LDKInitFeatures *NONNULL_PTR o);
46535 export function InitFeatures_hash(o: bigint): bigint {
46536 if(!isWasmInitialized) {
46537 throw new Error("initializeWasm() must be awaited first!");
46539 const nativeResponseValue = wasm.TS_InitFeatures_hash(o);
46540 return nativeResponseValue;
46542 // uint64_t NodeFeatures_hash(const struct LDKNodeFeatures *NONNULL_PTR o);
46544 export function NodeFeatures_hash(o: bigint): bigint {
46545 if(!isWasmInitialized) {
46546 throw new Error("initializeWasm() must be awaited first!");
46548 const nativeResponseValue = wasm.TS_NodeFeatures_hash(o);
46549 return nativeResponseValue;
46551 // uint64_t ChannelFeatures_hash(const struct LDKChannelFeatures *NONNULL_PTR o);
46553 export function ChannelFeatures_hash(o: bigint): bigint {
46554 if(!isWasmInitialized) {
46555 throw new Error("initializeWasm() must be awaited first!");
46557 const nativeResponseValue = wasm.TS_ChannelFeatures_hash(o);
46558 return nativeResponseValue;
46560 // uint64_t Bolt11InvoiceFeatures_hash(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR o);
46562 export function Bolt11InvoiceFeatures_hash(o: bigint): bigint {
46563 if(!isWasmInitialized) {
46564 throw new Error("initializeWasm() must be awaited first!");
46566 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_hash(o);
46567 return nativeResponseValue;
46569 // uint64_t OfferFeatures_hash(const struct LDKOfferFeatures *NONNULL_PTR o);
46571 export function OfferFeatures_hash(o: bigint): bigint {
46572 if(!isWasmInitialized) {
46573 throw new Error("initializeWasm() must be awaited first!");
46575 const nativeResponseValue = wasm.TS_OfferFeatures_hash(o);
46576 return nativeResponseValue;
46578 // uint64_t InvoiceRequestFeatures_hash(const struct LDKInvoiceRequestFeatures *NONNULL_PTR o);
46580 export function InvoiceRequestFeatures_hash(o: bigint): bigint {
46581 if(!isWasmInitialized) {
46582 throw new Error("initializeWasm() must be awaited first!");
46584 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_hash(o);
46585 return nativeResponseValue;
46587 // uint64_t Bolt12InvoiceFeatures_hash(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR o);
46589 export function Bolt12InvoiceFeatures_hash(o: bigint): bigint {
46590 if(!isWasmInitialized) {
46591 throw new Error("initializeWasm() must be awaited first!");
46593 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_hash(o);
46594 return nativeResponseValue;
46596 // uint64_t BlindedHopFeatures_hash(const struct LDKBlindedHopFeatures *NONNULL_PTR o);
46598 export function BlindedHopFeatures_hash(o: bigint): bigint {
46599 if(!isWasmInitialized) {
46600 throw new Error("initializeWasm() must be awaited first!");
46602 const nativeResponseValue = wasm.TS_BlindedHopFeatures_hash(o);
46603 return nativeResponseValue;
46605 // uint64_t ChannelTypeFeatures_hash(const struct LDKChannelTypeFeatures *NONNULL_PTR o);
46607 export function ChannelTypeFeatures_hash(o: bigint): bigint {
46608 if(!isWasmInitialized) {
46609 throw new Error("initializeWasm() must be awaited first!");
46611 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_hash(o);
46612 return nativeResponseValue;
46614 // void InitFeatures_free(struct LDKInitFeatures this_obj);
46616 export function InitFeatures_free(this_obj: bigint): void {
46617 if(!isWasmInitialized) {
46618 throw new Error("initializeWasm() must be awaited first!");
46620 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
46621 // debug statements here
46623 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
46625 export function NodeFeatures_free(this_obj: bigint): void {
46626 if(!isWasmInitialized) {
46627 throw new Error("initializeWasm() must be awaited first!");
46629 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
46630 // debug statements here
46632 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
46634 export function ChannelFeatures_free(this_obj: bigint): void {
46635 if(!isWasmInitialized) {
46636 throw new Error("initializeWasm() must be awaited first!");
46638 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
46639 // debug statements here
46641 // void Bolt11InvoiceFeatures_free(struct LDKBolt11InvoiceFeatures this_obj);
46643 export function Bolt11InvoiceFeatures_free(this_obj: bigint): void {
46644 if(!isWasmInitialized) {
46645 throw new Error("initializeWasm() must be awaited first!");
46647 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_free(this_obj);
46648 // debug statements here
46650 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
46652 export function OfferFeatures_free(this_obj: bigint): void {
46653 if(!isWasmInitialized) {
46654 throw new Error("initializeWasm() must be awaited first!");
46656 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
46657 // debug statements here
46659 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
46661 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
46662 if(!isWasmInitialized) {
46663 throw new Error("initializeWasm() must be awaited first!");
46665 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
46666 // debug statements here
46668 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
46670 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
46671 if(!isWasmInitialized) {
46672 throw new Error("initializeWasm() must be awaited first!");
46674 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
46675 // debug statements here
46677 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
46679 export function BlindedHopFeatures_free(this_obj: bigint): void {
46680 if(!isWasmInitialized) {
46681 throw new Error("initializeWasm() must be awaited first!");
46683 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
46684 // debug statements here
46686 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
46688 export function ChannelTypeFeatures_free(this_obj: bigint): void {
46689 if(!isWasmInitialized) {
46690 throw new Error("initializeWasm() must be awaited first!");
46692 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
46693 // debug statements here
46695 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
46697 export function InitFeatures_empty(): bigint {
46698 if(!isWasmInitialized) {
46699 throw new Error("initializeWasm() must be awaited first!");
46701 const nativeResponseValue = wasm.TS_InitFeatures_empty();
46702 return nativeResponseValue;
46704 // MUST_USE_RES bool InitFeatures_requires_unknown_bits_from(const struct LDKInitFeatures *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR other);
46706 export function InitFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
46707 if(!isWasmInitialized) {
46708 throw new Error("initializeWasm() must be awaited first!");
46710 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits_from(this_arg, other);
46711 return nativeResponseValue;
46713 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
46715 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
46716 if(!isWasmInitialized) {
46717 throw new Error("initializeWasm() must be awaited first!");
46719 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
46720 return nativeResponseValue;
46722 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46724 export function InitFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
46725 if(!isWasmInitialized) {
46726 throw new Error("initializeWasm() must be awaited first!");
46728 const nativeResponseValue = wasm.TS_InitFeatures_set_required_feature_bit(this_arg, bit);
46729 return nativeResponseValue;
46731 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46733 export function InitFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
46734 if(!isWasmInitialized) {
46735 throw new Error("initializeWasm() must be awaited first!");
46737 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_feature_bit(this_arg, bit);
46738 return nativeResponseValue;
46740 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46742 export function InitFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
46743 if(!isWasmInitialized) {
46744 throw new Error("initializeWasm() must be awaited first!");
46746 const nativeResponseValue = wasm.TS_InitFeatures_set_required_custom_bit(this_arg, bit);
46747 return nativeResponseValue;
46749 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46751 export function InitFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
46752 if(!isWasmInitialized) {
46753 throw new Error("initializeWasm() must be awaited first!");
46755 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_custom_bit(this_arg, bit);
46756 return nativeResponseValue;
46758 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
46760 export function NodeFeatures_empty(): bigint {
46761 if(!isWasmInitialized) {
46762 throw new Error("initializeWasm() must be awaited first!");
46764 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
46765 return nativeResponseValue;
46767 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits_from(const struct LDKNodeFeatures *NONNULL_PTR this_arg, const struct LDKNodeFeatures *NONNULL_PTR other);
46769 export function NodeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
46770 if(!isWasmInitialized) {
46771 throw new Error("initializeWasm() must be awaited first!");
46773 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits_from(this_arg, other);
46774 return nativeResponseValue;
46776 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
46778 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
46779 if(!isWasmInitialized) {
46780 throw new Error("initializeWasm() must be awaited first!");
46782 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
46783 return nativeResponseValue;
46785 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46787 export function NodeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
46788 if(!isWasmInitialized) {
46789 throw new Error("initializeWasm() must be awaited first!");
46791 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_feature_bit(this_arg, bit);
46792 return nativeResponseValue;
46794 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46796 export function NodeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
46797 if(!isWasmInitialized) {
46798 throw new Error("initializeWasm() must be awaited first!");
46800 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_feature_bit(this_arg, bit);
46801 return nativeResponseValue;
46803 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46805 export function NodeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
46806 if(!isWasmInitialized) {
46807 throw new Error("initializeWasm() must be awaited first!");
46809 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_custom_bit(this_arg, bit);
46810 return nativeResponseValue;
46812 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46814 export function NodeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
46815 if(!isWasmInitialized) {
46816 throw new Error("initializeWasm() must be awaited first!");
46818 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_custom_bit(this_arg, bit);
46819 return nativeResponseValue;
46821 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
46823 export function ChannelFeatures_empty(): bigint {
46824 if(!isWasmInitialized) {
46825 throw new Error("initializeWasm() must be awaited first!");
46827 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
46828 return nativeResponseValue;
46830 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits_from(const struct LDKChannelFeatures *NONNULL_PTR this_arg, const struct LDKChannelFeatures *NONNULL_PTR other);
46832 export function ChannelFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
46833 if(!isWasmInitialized) {
46834 throw new Error("initializeWasm() must be awaited first!");
46836 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits_from(this_arg, other);
46837 return nativeResponseValue;
46839 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
46841 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
46842 if(!isWasmInitialized) {
46843 throw new Error("initializeWasm() must be awaited first!");
46845 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
46846 return nativeResponseValue;
46848 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46850 export function ChannelFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
46851 if(!isWasmInitialized) {
46852 throw new Error("initializeWasm() must be awaited first!");
46854 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_feature_bit(this_arg, bit);
46855 return nativeResponseValue;
46857 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46859 export function ChannelFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
46860 if(!isWasmInitialized) {
46861 throw new Error("initializeWasm() must be awaited first!");
46863 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_feature_bit(this_arg, bit);
46864 return nativeResponseValue;
46866 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46868 export function ChannelFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
46869 if(!isWasmInitialized) {
46870 throw new Error("initializeWasm() must be awaited first!");
46872 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_custom_bit(this_arg, bit);
46873 return nativeResponseValue;
46875 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46877 export function ChannelFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
46878 if(!isWasmInitialized) {
46879 throw new Error("initializeWasm() must be awaited first!");
46881 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_custom_bit(this_arg, bit);
46882 return nativeResponseValue;
46884 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_empty(void);
46886 export function Bolt11InvoiceFeatures_empty(): bigint {
46887 if(!isWasmInitialized) {
46888 throw new Error("initializeWasm() must be awaited first!");
46890 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_empty();
46891 return nativeResponseValue;
46893 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR other);
46895 export function Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
46896 if(!isWasmInitialized) {
46897 throw new Error("initializeWasm() must be awaited first!");
46899 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
46900 return nativeResponseValue;
46902 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
46904 export function Bolt11InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
46905 if(!isWasmInitialized) {
46906 throw new Error("initializeWasm() must be awaited first!");
46908 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits(this_arg);
46909 return nativeResponseValue;
46911 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46913 export function Bolt11InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
46914 if(!isWasmInitialized) {
46915 throw new Error("initializeWasm() must be awaited first!");
46917 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_feature_bit(this_arg, bit);
46918 return nativeResponseValue;
46920 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46922 export function Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
46923 if(!isWasmInitialized) {
46924 throw new Error("initializeWasm() must be awaited first!");
46926 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
46927 return nativeResponseValue;
46929 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46931 export function Bolt11InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
46932 if(!isWasmInitialized) {
46933 throw new Error("initializeWasm() must be awaited first!");
46935 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_custom_bit(this_arg, bit);
46936 return nativeResponseValue;
46938 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46940 export function Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
46941 if(!isWasmInitialized) {
46942 throw new Error("initializeWasm() must be awaited first!");
46944 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
46945 return nativeResponseValue;
46947 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
46949 export function OfferFeatures_empty(): bigint {
46950 if(!isWasmInitialized) {
46951 throw new Error("initializeWasm() must be awaited first!");
46953 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
46954 return nativeResponseValue;
46956 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits_from(const struct LDKOfferFeatures *NONNULL_PTR this_arg, const struct LDKOfferFeatures *NONNULL_PTR other);
46958 export function OfferFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
46959 if(!isWasmInitialized) {
46960 throw new Error("initializeWasm() must be awaited first!");
46962 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits_from(this_arg, other);
46963 return nativeResponseValue;
46965 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
46967 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
46968 if(!isWasmInitialized) {
46969 throw new Error("initializeWasm() must be awaited first!");
46971 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
46972 return nativeResponseValue;
46974 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46976 export function OfferFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
46977 if(!isWasmInitialized) {
46978 throw new Error("initializeWasm() must be awaited first!");
46980 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_feature_bit(this_arg, bit);
46981 return nativeResponseValue;
46983 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46985 export function OfferFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
46986 if(!isWasmInitialized) {
46987 throw new Error("initializeWasm() must be awaited first!");
46989 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_feature_bit(this_arg, bit);
46990 return nativeResponseValue;
46992 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
46994 export function OfferFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
46995 if(!isWasmInitialized) {
46996 throw new Error("initializeWasm() must be awaited first!");
46998 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_custom_bit(this_arg, bit);
46999 return nativeResponseValue;
47001 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47003 export function OfferFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
47004 if(!isWasmInitialized) {
47005 throw new Error("initializeWasm() must be awaited first!");
47007 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_custom_bit(this_arg, bit);
47008 return nativeResponseValue;
47010 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
47012 export function InvoiceRequestFeatures_empty(): bigint {
47013 if(!isWasmInitialized) {
47014 throw new Error("initializeWasm() must be awaited first!");
47016 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
47017 return nativeResponseValue;
47019 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits_from(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, const struct LDKInvoiceRequestFeatures *NONNULL_PTR other);
47021 export function InvoiceRequestFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
47022 if(!isWasmInitialized) {
47023 throw new Error("initializeWasm() must be awaited first!");
47025 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits_from(this_arg, other);
47026 return nativeResponseValue;
47028 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
47030 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
47031 if(!isWasmInitialized) {
47032 throw new Error("initializeWasm() must be awaited first!");
47034 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
47035 return nativeResponseValue;
47037 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47039 export function InvoiceRequestFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
47040 if(!isWasmInitialized) {
47041 throw new Error("initializeWasm() must be awaited first!");
47043 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_feature_bit(this_arg, bit);
47044 return nativeResponseValue;
47046 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47048 export function InvoiceRequestFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
47049 if(!isWasmInitialized) {
47050 throw new Error("initializeWasm() must be awaited first!");
47052 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_feature_bit(this_arg, bit);
47053 return nativeResponseValue;
47055 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47057 export function InvoiceRequestFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
47058 if(!isWasmInitialized) {
47059 throw new Error("initializeWasm() must be awaited first!");
47061 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_custom_bit(this_arg, bit);
47062 return nativeResponseValue;
47064 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47066 export function InvoiceRequestFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
47067 if(!isWasmInitialized) {
47068 throw new Error("initializeWasm() must be awaited first!");
47070 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_custom_bit(this_arg, bit);
47071 return nativeResponseValue;
47073 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
47075 export function Bolt12InvoiceFeatures_empty(): bigint {
47076 if(!isWasmInitialized) {
47077 throw new Error("initializeWasm() must be awaited first!");
47079 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
47080 return nativeResponseValue;
47082 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR other);
47084 export function Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
47085 if(!isWasmInitialized) {
47086 throw new Error("initializeWasm() must be awaited first!");
47088 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
47089 return nativeResponseValue;
47091 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
47093 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
47094 if(!isWasmInitialized) {
47095 throw new Error("initializeWasm() must be awaited first!");
47097 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
47098 return nativeResponseValue;
47100 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47102 export function Bolt12InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
47103 if(!isWasmInitialized) {
47104 throw new Error("initializeWasm() must be awaited first!");
47106 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_feature_bit(this_arg, bit);
47107 return nativeResponseValue;
47109 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47111 export function Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
47112 if(!isWasmInitialized) {
47113 throw new Error("initializeWasm() must be awaited first!");
47115 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
47116 return nativeResponseValue;
47118 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47120 export function Bolt12InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
47121 if(!isWasmInitialized) {
47122 throw new Error("initializeWasm() must be awaited first!");
47124 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_custom_bit(this_arg, bit);
47125 return nativeResponseValue;
47127 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47129 export function Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
47130 if(!isWasmInitialized) {
47131 throw new Error("initializeWasm() must be awaited first!");
47133 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
47134 return nativeResponseValue;
47136 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
47138 export function BlindedHopFeatures_empty(): bigint {
47139 if(!isWasmInitialized) {
47140 throw new Error("initializeWasm() must be awaited first!");
47142 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
47143 return nativeResponseValue;
47145 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits_from(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, const struct LDKBlindedHopFeatures *NONNULL_PTR other);
47147 export function BlindedHopFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
47148 if(!isWasmInitialized) {
47149 throw new Error("initializeWasm() must be awaited first!");
47151 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits_from(this_arg, other);
47152 return nativeResponseValue;
47154 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
47156 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
47157 if(!isWasmInitialized) {
47158 throw new Error("initializeWasm() must be awaited first!");
47160 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
47161 return nativeResponseValue;
47163 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47165 export function BlindedHopFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
47166 if(!isWasmInitialized) {
47167 throw new Error("initializeWasm() must be awaited first!");
47169 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_feature_bit(this_arg, bit);
47170 return nativeResponseValue;
47172 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47174 export function BlindedHopFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
47175 if(!isWasmInitialized) {
47176 throw new Error("initializeWasm() must be awaited first!");
47178 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_feature_bit(this_arg, bit);
47179 return nativeResponseValue;
47181 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47183 export function BlindedHopFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
47184 if(!isWasmInitialized) {
47185 throw new Error("initializeWasm() must be awaited first!");
47187 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_custom_bit(this_arg, bit);
47188 return nativeResponseValue;
47190 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47192 export function BlindedHopFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
47193 if(!isWasmInitialized) {
47194 throw new Error("initializeWasm() must be awaited first!");
47196 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_custom_bit(this_arg, bit);
47197 return nativeResponseValue;
47199 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
47201 export function ChannelTypeFeatures_empty(): bigint {
47202 if(!isWasmInitialized) {
47203 throw new Error("initializeWasm() must be awaited first!");
47205 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
47206 return nativeResponseValue;
47208 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits_from(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, const struct LDKChannelTypeFeatures *NONNULL_PTR other);
47210 export function ChannelTypeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
47211 if(!isWasmInitialized) {
47212 throw new Error("initializeWasm() must be awaited first!");
47214 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits_from(this_arg, other);
47215 return nativeResponseValue;
47217 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
47219 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
47220 if(!isWasmInitialized) {
47221 throw new Error("initializeWasm() must be awaited first!");
47223 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
47224 return nativeResponseValue;
47226 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47228 export function ChannelTypeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
47229 if(!isWasmInitialized) {
47230 throw new Error("initializeWasm() must be awaited first!");
47232 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_feature_bit(this_arg, bit);
47233 return nativeResponseValue;
47235 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47237 export function ChannelTypeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
47238 if(!isWasmInitialized) {
47239 throw new Error("initializeWasm() must be awaited first!");
47241 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_feature_bit(this_arg, bit);
47242 return nativeResponseValue;
47244 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47246 export function ChannelTypeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
47247 if(!isWasmInitialized) {
47248 throw new Error("initializeWasm() must be awaited first!");
47250 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_custom_bit(this_arg, bit);
47251 return nativeResponseValue;
47253 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
47255 export function ChannelTypeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
47256 if(!isWasmInitialized) {
47257 throw new Error("initializeWasm() must be awaited first!");
47259 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_custom_bit(this_arg, bit);
47260 return nativeResponseValue;
47262 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
47264 export function InitFeatures_write(obj: bigint): number {
47265 if(!isWasmInitialized) {
47266 throw new Error("initializeWasm() must be awaited first!");
47268 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
47269 return nativeResponseValue;
47271 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
47273 export function InitFeatures_read(ser: number): bigint {
47274 if(!isWasmInitialized) {
47275 throw new Error("initializeWasm() must be awaited first!");
47277 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
47278 return nativeResponseValue;
47280 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
47282 export function ChannelFeatures_write(obj: bigint): number {
47283 if(!isWasmInitialized) {
47284 throw new Error("initializeWasm() must be awaited first!");
47286 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
47287 return nativeResponseValue;
47289 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
47291 export function ChannelFeatures_read(ser: number): bigint {
47292 if(!isWasmInitialized) {
47293 throw new Error("initializeWasm() must be awaited first!");
47295 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
47296 return nativeResponseValue;
47298 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
47300 export function NodeFeatures_write(obj: bigint): number {
47301 if(!isWasmInitialized) {
47302 throw new Error("initializeWasm() must be awaited first!");
47304 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
47305 return nativeResponseValue;
47307 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
47309 export function NodeFeatures_read(ser: number): bigint {
47310 if(!isWasmInitialized) {
47311 throw new Error("initializeWasm() must be awaited first!");
47313 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
47314 return nativeResponseValue;
47316 // struct LDKCVec_u8Z Bolt11InvoiceFeatures_write(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR obj);
47318 export function Bolt11InvoiceFeatures_write(obj: bigint): number {
47319 if(!isWasmInitialized) {
47320 throw new Error("initializeWasm() must be awaited first!");
47322 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_write(obj);
47323 return nativeResponseValue;
47325 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ Bolt11InvoiceFeatures_read(struct LDKu8slice ser);
47327 export function Bolt11InvoiceFeatures_read(ser: number): bigint {
47328 if(!isWasmInitialized) {
47329 throw new Error("initializeWasm() must be awaited first!");
47331 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_read(ser);
47332 return nativeResponseValue;
47334 // struct LDKCVec_u8Z Bolt12InvoiceFeatures_write(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR obj);
47336 export function Bolt12InvoiceFeatures_write(obj: bigint): number {
47337 if(!isWasmInitialized) {
47338 throw new Error("initializeWasm() must be awaited first!");
47340 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_write(obj);
47341 return nativeResponseValue;
47343 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ Bolt12InvoiceFeatures_read(struct LDKu8slice ser);
47345 export function Bolt12InvoiceFeatures_read(ser: number): bigint {
47346 if(!isWasmInitialized) {
47347 throw new Error("initializeWasm() must be awaited first!");
47349 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_read(ser);
47350 return nativeResponseValue;
47352 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
47354 export function BlindedHopFeatures_write(obj: bigint): number {
47355 if(!isWasmInitialized) {
47356 throw new Error("initializeWasm() must be awaited first!");
47358 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
47359 return nativeResponseValue;
47361 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
47363 export function BlindedHopFeatures_read(ser: number): bigint {
47364 if(!isWasmInitialized) {
47365 throw new Error("initializeWasm() must be awaited first!");
47367 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
47368 return nativeResponseValue;
47370 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
47372 export function ChannelTypeFeatures_write(obj: bigint): number {
47373 if(!isWasmInitialized) {
47374 throw new Error("initializeWasm() must be awaited first!");
47376 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
47377 return nativeResponseValue;
47379 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
47381 export function ChannelTypeFeatures_read(ser: number): bigint {
47382 if(!isWasmInitialized) {
47383 throw new Error("initializeWasm() must be awaited first!");
47385 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
47386 return nativeResponseValue;
47388 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47390 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
47391 if(!isWasmInitialized) {
47392 throw new Error("initializeWasm() must be awaited first!");
47394 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
47395 // debug statements here
47397 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47399 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
47400 if(!isWasmInitialized) {
47401 throw new Error("initializeWasm() must be awaited first!");
47403 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
47404 // debug statements here
47406 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47408 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
47409 if(!isWasmInitialized) {
47410 throw new Error("initializeWasm() must be awaited first!");
47412 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
47413 return nativeResponseValue;
47415 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47417 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
47418 if(!isWasmInitialized) {
47419 throw new Error("initializeWasm() must be awaited first!");
47421 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
47422 // debug statements here
47424 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47426 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
47427 if(!isWasmInitialized) {
47428 throw new Error("initializeWasm() must be awaited first!");
47430 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
47431 // debug statements here
47433 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47435 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
47436 if(!isWasmInitialized) {
47437 throw new Error("initializeWasm() must be awaited first!");
47439 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
47440 return nativeResponseValue;
47442 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47444 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
47445 if(!isWasmInitialized) {
47446 throw new Error("initializeWasm() must be awaited first!");
47448 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
47449 return nativeResponseValue;
47451 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47453 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
47454 if(!isWasmInitialized) {
47455 throw new Error("initializeWasm() must be awaited first!");
47457 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
47458 return nativeResponseValue;
47460 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47462 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
47463 if(!isWasmInitialized) {
47464 throw new Error("initializeWasm() must be awaited first!");
47466 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
47467 // debug statements here
47469 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47471 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
47472 if(!isWasmInitialized) {
47473 throw new Error("initializeWasm() must be awaited first!");
47475 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
47476 // debug statements here
47478 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47480 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
47481 if(!isWasmInitialized) {
47482 throw new Error("initializeWasm() must be awaited first!");
47484 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
47485 return nativeResponseValue;
47487 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47489 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
47490 if(!isWasmInitialized) {
47491 throw new Error("initializeWasm() must be awaited first!");
47493 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
47494 // debug statements here
47496 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47498 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
47499 if(!isWasmInitialized) {
47500 throw new Error("initializeWasm() must be awaited first!");
47502 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
47503 // debug statements here
47505 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47507 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
47508 if(!isWasmInitialized) {
47509 throw new Error("initializeWasm() must be awaited first!");
47511 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
47512 return nativeResponseValue;
47514 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47516 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
47517 if(!isWasmInitialized) {
47518 throw new Error("initializeWasm() must be awaited first!");
47520 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
47521 // debug statements here
47523 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47525 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
47526 if(!isWasmInitialized) {
47527 throw new Error("initializeWasm() must be awaited first!");
47529 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
47530 // debug statements here
47532 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47534 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
47535 if(!isWasmInitialized) {
47536 throw new Error("initializeWasm() must be awaited first!");
47538 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
47539 return nativeResponseValue;
47541 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47543 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
47544 if(!isWasmInitialized) {
47545 throw new Error("initializeWasm() must be awaited first!");
47547 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
47548 return nativeResponseValue;
47550 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47552 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
47553 if(!isWasmInitialized) {
47554 throw new Error("initializeWasm() must be awaited first!");
47556 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
47557 return nativeResponseValue;
47559 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47561 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
47562 if(!isWasmInitialized) {
47563 throw new Error("initializeWasm() must be awaited first!");
47565 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
47566 // debug statements here
47568 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47570 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
47571 if(!isWasmInitialized) {
47572 throw new Error("initializeWasm() must be awaited first!");
47574 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
47575 // debug statements here
47577 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47579 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
47580 if(!isWasmInitialized) {
47581 throw new Error("initializeWasm() must be awaited first!");
47583 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
47584 return nativeResponseValue;
47586 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47588 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
47589 if(!isWasmInitialized) {
47590 throw new Error("initializeWasm() must be awaited first!");
47592 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
47593 // debug statements here
47595 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47597 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
47598 if(!isWasmInitialized) {
47599 throw new Error("initializeWasm() must be awaited first!");
47601 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
47602 // debug statements here
47604 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47606 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
47607 if(!isWasmInitialized) {
47608 throw new Error("initializeWasm() must be awaited first!");
47610 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
47611 return nativeResponseValue;
47613 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47615 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
47616 if(!isWasmInitialized) {
47617 throw new Error("initializeWasm() must be awaited first!");
47619 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
47620 return nativeResponseValue;
47622 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47624 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
47625 if(!isWasmInitialized) {
47626 throw new Error("initializeWasm() must be awaited first!");
47628 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
47629 return nativeResponseValue;
47631 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47633 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
47634 if(!isWasmInitialized) {
47635 throw new Error("initializeWasm() must be awaited first!");
47637 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
47638 // debug statements here
47640 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47642 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
47643 if(!isWasmInitialized) {
47644 throw new Error("initializeWasm() must be awaited first!");
47646 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
47647 // debug statements here
47649 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47651 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
47652 if(!isWasmInitialized) {
47653 throw new Error("initializeWasm() must be awaited first!");
47655 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
47656 return nativeResponseValue;
47658 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47660 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
47661 if(!isWasmInitialized) {
47662 throw new Error("initializeWasm() must be awaited first!");
47664 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
47665 // debug statements here
47667 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47669 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
47670 if(!isWasmInitialized) {
47671 throw new Error("initializeWasm() must be awaited first!");
47673 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
47674 // debug statements here
47676 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47678 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
47679 if(!isWasmInitialized) {
47680 throw new Error("initializeWasm() must be awaited first!");
47682 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
47683 return nativeResponseValue;
47685 // void Bolt11InvoiceFeatures_set_variable_length_onion_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47687 export function Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
47688 if(!isWasmInitialized) {
47689 throw new Error("initializeWasm() must be awaited first!");
47691 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg);
47692 // debug statements here
47694 // void Bolt11InvoiceFeatures_set_variable_length_onion_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47696 export function Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
47697 if(!isWasmInitialized) {
47698 throw new Error("initializeWasm() must be awaited first!");
47700 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg);
47701 // debug statements here
47703 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47705 export function Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
47706 if(!isWasmInitialized) {
47707 throw new Error("initializeWasm() must be awaited first!");
47709 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg);
47710 return nativeResponseValue;
47712 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47714 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
47715 if(!isWasmInitialized) {
47716 throw new Error("initializeWasm() must be awaited first!");
47718 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
47719 return nativeResponseValue;
47721 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47723 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
47724 if(!isWasmInitialized) {
47725 throw new Error("initializeWasm() must be awaited first!");
47727 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
47728 return nativeResponseValue;
47730 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47732 export function Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
47733 if(!isWasmInitialized) {
47734 throw new Error("initializeWasm() must be awaited first!");
47736 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg);
47737 return nativeResponseValue;
47739 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47741 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
47742 if(!isWasmInitialized) {
47743 throw new Error("initializeWasm() must be awaited first!");
47745 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
47746 // debug statements here
47748 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47750 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
47751 if(!isWasmInitialized) {
47752 throw new Error("initializeWasm() must be awaited first!");
47754 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
47755 // debug statements here
47757 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47759 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
47760 if(!isWasmInitialized) {
47761 throw new Error("initializeWasm() must be awaited first!");
47763 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
47764 return nativeResponseValue;
47766 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47768 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
47769 if(!isWasmInitialized) {
47770 throw new Error("initializeWasm() must be awaited first!");
47772 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
47773 // debug statements here
47775 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47777 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
47778 if(!isWasmInitialized) {
47779 throw new Error("initializeWasm() must be awaited first!");
47781 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
47782 // debug statements here
47784 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47786 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
47787 if(!isWasmInitialized) {
47788 throw new Error("initializeWasm() must be awaited first!");
47790 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
47791 return nativeResponseValue;
47793 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
47795 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
47796 if(!isWasmInitialized) {
47797 throw new Error("initializeWasm() must be awaited first!");
47799 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
47800 // debug statements here
47802 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
47804 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
47805 if(!isWasmInitialized) {
47806 throw new Error("initializeWasm() must be awaited first!");
47808 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
47809 // debug statements here
47811 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
47813 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
47814 if(!isWasmInitialized) {
47815 throw new Error("initializeWasm() must be awaited first!");
47817 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
47818 return nativeResponseValue;
47820 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47822 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
47823 if(!isWasmInitialized) {
47824 throw new Error("initializeWasm() must be awaited first!");
47826 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
47827 return nativeResponseValue;
47829 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47831 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
47832 if(!isWasmInitialized) {
47833 throw new Error("initializeWasm() must be awaited first!");
47835 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
47836 return nativeResponseValue;
47838 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
47840 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
47841 if(!isWasmInitialized) {
47842 throw new Error("initializeWasm() must be awaited first!");
47844 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
47845 return nativeResponseValue;
47847 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47849 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
47850 if(!isWasmInitialized) {
47851 throw new Error("initializeWasm() must be awaited first!");
47853 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
47854 // debug statements here
47856 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47858 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
47859 if(!isWasmInitialized) {
47860 throw new Error("initializeWasm() must be awaited first!");
47862 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
47863 // debug statements here
47865 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47867 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
47868 if(!isWasmInitialized) {
47869 throw new Error("initializeWasm() must be awaited first!");
47871 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
47872 return nativeResponseValue;
47874 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47876 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
47877 if(!isWasmInitialized) {
47878 throw new Error("initializeWasm() must be awaited first!");
47880 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
47881 // debug statements here
47883 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47885 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
47886 if(!isWasmInitialized) {
47887 throw new Error("initializeWasm() must be awaited first!");
47889 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
47890 // debug statements here
47892 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47894 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
47895 if(!isWasmInitialized) {
47896 throw new Error("initializeWasm() must be awaited first!");
47898 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
47899 return nativeResponseValue;
47901 // void Bolt11InvoiceFeatures_set_payment_secret_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47903 export function Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
47904 if(!isWasmInitialized) {
47905 throw new Error("initializeWasm() must be awaited first!");
47907 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg);
47908 // debug statements here
47910 // void Bolt11InvoiceFeatures_set_payment_secret_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47912 export function Bolt11InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
47913 if(!isWasmInitialized) {
47914 throw new Error("initializeWasm() must be awaited first!");
47916 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_required(this_arg);
47917 // debug statements here
47919 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47921 export function Bolt11InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
47922 if(!isWasmInitialized) {
47923 throw new Error("initializeWasm() must be awaited first!");
47925 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_secret(this_arg);
47926 return nativeResponseValue;
47928 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47930 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
47931 if(!isWasmInitialized) {
47932 throw new Error("initializeWasm() must be awaited first!");
47934 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
47935 return nativeResponseValue;
47937 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
47939 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
47940 if(!isWasmInitialized) {
47941 throw new Error("initializeWasm() must be awaited first!");
47943 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
47944 return nativeResponseValue;
47946 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
47948 export function Bolt11InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
47949 if(!isWasmInitialized) {
47950 throw new Error("initializeWasm() must be awaited first!");
47952 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_secret(this_arg);
47953 return nativeResponseValue;
47955 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
47957 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
47958 if(!isWasmInitialized) {
47959 throw new Error("initializeWasm() must be awaited first!");
47961 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
47962 // debug statements here
47964 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
47966 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
47967 if(!isWasmInitialized) {
47968 throw new Error("initializeWasm() must be awaited first!");
47970 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
47971 // debug statements here
47973 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
47975 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
47976 if(!isWasmInitialized) {
47977 throw new Error("initializeWasm() must be awaited first!");
47979 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
47980 return nativeResponseValue;
47982 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47984 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
47985 if(!isWasmInitialized) {
47986 throw new Error("initializeWasm() must be awaited first!");
47988 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
47989 // debug statements here
47991 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
47993 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
47994 if(!isWasmInitialized) {
47995 throw new Error("initializeWasm() must be awaited first!");
47997 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
47998 // debug statements here
48000 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48002 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
48003 if(!isWasmInitialized) {
48004 throw new Error("initializeWasm() must be awaited first!");
48006 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
48007 return nativeResponseValue;
48009 // void Bolt11InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48011 export function Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
48012 if(!isWasmInitialized) {
48013 throw new Error("initializeWasm() must be awaited first!");
48015 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg);
48016 // debug statements here
48018 // void Bolt11InvoiceFeatures_set_basic_mpp_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48020 export function Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
48021 if(!isWasmInitialized) {
48022 throw new Error("initializeWasm() must be awaited first!");
48024 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg);
48025 // debug statements here
48027 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48029 export function Bolt11InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
48030 if(!isWasmInitialized) {
48031 throw new Error("initializeWasm() must be awaited first!");
48033 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_basic_mpp(this_arg);
48034 return nativeResponseValue;
48036 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
48038 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
48039 if(!isWasmInitialized) {
48040 throw new Error("initializeWasm() must be awaited first!");
48042 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
48043 // debug statements here
48045 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
48047 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
48048 if(!isWasmInitialized) {
48049 throw new Error("initializeWasm() must be awaited first!");
48051 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
48052 // debug statements here
48054 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
48056 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
48057 if(!isWasmInitialized) {
48058 throw new Error("initializeWasm() must be awaited first!");
48060 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
48061 return nativeResponseValue;
48063 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48065 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
48066 if(!isWasmInitialized) {
48067 throw new Error("initializeWasm() must be awaited first!");
48069 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
48070 return nativeResponseValue;
48072 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48074 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
48075 if(!isWasmInitialized) {
48076 throw new Error("initializeWasm() must be awaited first!");
48078 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
48079 return nativeResponseValue;
48081 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48083 export function Bolt11InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
48084 if(!isWasmInitialized) {
48085 throw new Error("initializeWasm() must be awaited first!");
48087 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_basic_mpp(this_arg);
48088 return nativeResponseValue;
48090 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
48092 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
48093 if(!isWasmInitialized) {
48094 throw new Error("initializeWasm() must be awaited first!");
48096 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
48097 return nativeResponseValue;
48099 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48101 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
48102 if(!isWasmInitialized) {
48103 throw new Error("initializeWasm() must be awaited first!");
48105 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
48106 // debug statements here
48108 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48110 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
48111 if(!isWasmInitialized) {
48112 throw new Error("initializeWasm() must be awaited first!");
48114 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
48115 // debug statements here
48117 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48119 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
48120 if(!isWasmInitialized) {
48121 throw new Error("initializeWasm() must be awaited first!");
48123 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
48124 return nativeResponseValue;
48126 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48128 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
48129 if(!isWasmInitialized) {
48130 throw new Error("initializeWasm() must be awaited first!");
48132 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
48133 // debug statements here
48135 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48137 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
48138 if(!isWasmInitialized) {
48139 throw new Error("initializeWasm() must be awaited first!");
48141 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
48142 // debug statements here
48144 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48146 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
48147 if(!isWasmInitialized) {
48148 throw new Error("initializeWasm() must be awaited first!");
48150 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
48151 return nativeResponseValue;
48153 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48155 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
48156 if(!isWasmInitialized) {
48157 throw new Error("initializeWasm() must be awaited first!");
48159 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
48160 return nativeResponseValue;
48162 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48164 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
48165 if(!isWasmInitialized) {
48166 throw new Error("initializeWasm() must be awaited first!");
48168 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
48169 return nativeResponseValue;
48171 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48173 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
48174 if(!isWasmInitialized) {
48175 throw new Error("initializeWasm() must be awaited first!");
48177 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
48178 // debug statements here
48180 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48182 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
48183 if(!isWasmInitialized) {
48184 throw new Error("initializeWasm() must be awaited first!");
48186 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
48187 // debug statements here
48189 // MUST_USE_RES bool InitFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48191 export function InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48192 if(!isWasmInitialized) {
48193 throw new Error("initializeWasm() must be awaited first!");
48195 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
48196 return nativeResponseValue;
48198 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48200 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
48201 if(!isWasmInitialized) {
48202 throw new Error("initializeWasm() must be awaited first!");
48204 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
48205 // debug statements here
48207 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48209 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
48210 if(!isWasmInitialized) {
48211 throw new Error("initializeWasm() must be awaited first!");
48213 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
48214 // debug statements here
48216 // MUST_USE_RES bool NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48218 export function NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48219 if(!isWasmInitialized) {
48220 throw new Error("initializeWasm() must be awaited first!");
48222 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
48223 return nativeResponseValue;
48225 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48227 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
48228 if(!isWasmInitialized) {
48229 throw new Error("initializeWasm() must be awaited first!");
48231 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
48232 // debug statements here
48234 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48236 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
48237 if(!isWasmInitialized) {
48238 throw new Error("initializeWasm() must be awaited first!");
48240 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
48241 // debug statements here
48243 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48245 export function ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48246 if(!isWasmInitialized) {
48247 throw new Error("initializeWasm() must be awaited first!");
48249 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
48250 return nativeResponseValue;
48252 // MUST_USE_RES bool InitFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48254 export function InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48255 if(!isWasmInitialized) {
48256 throw new Error("initializeWasm() must be awaited first!");
48258 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
48259 return nativeResponseValue;
48261 // MUST_USE_RES bool NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48263 export function NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48264 if(!isWasmInitialized) {
48265 throw new Error("initializeWasm() must be awaited first!");
48267 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
48268 return nativeResponseValue;
48270 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48272 export function ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
48273 if(!isWasmInitialized) {
48274 throw new Error("initializeWasm() must be awaited first!");
48276 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
48277 return nativeResponseValue;
48279 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48281 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
48282 if(!isWasmInitialized) {
48283 throw new Error("initializeWasm() must be awaited first!");
48285 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
48286 // debug statements here
48288 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48290 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
48291 if(!isWasmInitialized) {
48292 throw new Error("initializeWasm() must be awaited first!");
48294 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
48295 // debug statements here
48297 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48299 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48300 if(!isWasmInitialized) {
48301 throw new Error("initializeWasm() must be awaited first!");
48303 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
48304 return nativeResponseValue;
48306 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48308 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
48309 if(!isWasmInitialized) {
48310 throw new Error("initializeWasm() must be awaited first!");
48312 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
48313 // debug statements here
48315 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48317 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
48318 if(!isWasmInitialized) {
48319 throw new Error("initializeWasm() must be awaited first!");
48321 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
48322 // debug statements here
48324 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48326 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48327 if(!isWasmInitialized) {
48328 throw new Error("initializeWasm() must be awaited first!");
48330 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
48331 return nativeResponseValue;
48333 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48335 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
48336 if(!isWasmInitialized) {
48337 throw new Error("initializeWasm() must be awaited first!");
48339 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
48340 // debug statements here
48342 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48344 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
48345 if(!isWasmInitialized) {
48346 throw new Error("initializeWasm() must be awaited first!");
48348 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
48349 // debug statements here
48351 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48353 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48354 if(!isWasmInitialized) {
48355 throw new Error("initializeWasm() must be awaited first!");
48357 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
48358 return nativeResponseValue;
48360 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48362 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48363 if(!isWasmInitialized) {
48364 throw new Error("initializeWasm() must be awaited first!");
48366 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
48367 return nativeResponseValue;
48369 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48371 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48372 if(!isWasmInitialized) {
48373 throw new Error("initializeWasm() must be awaited first!");
48375 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
48376 return nativeResponseValue;
48378 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48380 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
48381 if(!isWasmInitialized) {
48382 throw new Error("initializeWasm() must be awaited first!");
48384 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
48385 return nativeResponseValue;
48387 // void InitFeatures_set_route_blinding_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48389 export function InitFeatures_set_route_blinding_optional(this_arg: bigint): void {
48390 if(!isWasmInitialized) {
48391 throw new Error("initializeWasm() must be awaited first!");
48393 const nativeResponseValue = wasm.TS_InitFeatures_set_route_blinding_optional(this_arg);
48394 // debug statements here
48396 // void InitFeatures_set_route_blinding_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48398 export function InitFeatures_set_route_blinding_required(this_arg: bigint): void {
48399 if(!isWasmInitialized) {
48400 throw new Error("initializeWasm() must be awaited first!");
48402 const nativeResponseValue = wasm.TS_InitFeatures_set_route_blinding_required(this_arg);
48403 // debug statements here
48405 // MUST_USE_RES bool InitFeatures_supports_route_blinding(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48407 export function InitFeatures_supports_route_blinding(this_arg: bigint): boolean {
48408 if(!isWasmInitialized) {
48409 throw new Error("initializeWasm() must be awaited first!");
48411 const nativeResponseValue = wasm.TS_InitFeatures_supports_route_blinding(this_arg);
48412 return nativeResponseValue;
48414 // void NodeFeatures_set_route_blinding_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48416 export function NodeFeatures_set_route_blinding_optional(this_arg: bigint): void {
48417 if(!isWasmInitialized) {
48418 throw new Error("initializeWasm() must be awaited first!");
48420 const nativeResponseValue = wasm.TS_NodeFeatures_set_route_blinding_optional(this_arg);
48421 // debug statements here
48423 // void NodeFeatures_set_route_blinding_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48425 export function NodeFeatures_set_route_blinding_required(this_arg: bigint): void {
48426 if(!isWasmInitialized) {
48427 throw new Error("initializeWasm() must be awaited first!");
48429 const nativeResponseValue = wasm.TS_NodeFeatures_set_route_blinding_required(this_arg);
48430 // debug statements here
48432 // MUST_USE_RES bool NodeFeatures_supports_route_blinding(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48434 export function NodeFeatures_supports_route_blinding(this_arg: bigint): boolean {
48435 if(!isWasmInitialized) {
48436 throw new Error("initializeWasm() must be awaited first!");
48438 const nativeResponseValue = wasm.TS_NodeFeatures_supports_route_blinding(this_arg);
48439 return nativeResponseValue;
48441 // MUST_USE_RES bool InitFeatures_requires_route_blinding(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48443 export function InitFeatures_requires_route_blinding(this_arg: bigint): boolean {
48444 if(!isWasmInitialized) {
48445 throw new Error("initializeWasm() must be awaited first!");
48447 const nativeResponseValue = wasm.TS_InitFeatures_requires_route_blinding(this_arg);
48448 return nativeResponseValue;
48450 // MUST_USE_RES bool NodeFeatures_requires_route_blinding(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48452 export function NodeFeatures_requires_route_blinding(this_arg: bigint): boolean {
48453 if(!isWasmInitialized) {
48454 throw new Error("initializeWasm() must be awaited first!");
48456 const nativeResponseValue = wasm.TS_NodeFeatures_requires_route_blinding(this_arg);
48457 return nativeResponseValue;
48459 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48461 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
48462 if(!isWasmInitialized) {
48463 throw new Error("initializeWasm() must be awaited first!");
48465 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
48466 // debug statements here
48468 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48470 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
48471 if(!isWasmInitialized) {
48472 throw new Error("initializeWasm() must be awaited first!");
48474 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
48475 // debug statements here
48477 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48479 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
48480 if(!isWasmInitialized) {
48481 throw new Error("initializeWasm() must be awaited first!");
48483 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
48484 return nativeResponseValue;
48486 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48488 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
48489 if(!isWasmInitialized) {
48490 throw new Error("initializeWasm() must be awaited first!");
48492 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
48493 // debug statements here
48495 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48497 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
48498 if(!isWasmInitialized) {
48499 throw new Error("initializeWasm() must be awaited first!");
48501 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
48502 // debug statements here
48504 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48506 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
48507 if(!isWasmInitialized) {
48508 throw new Error("initializeWasm() must be awaited first!");
48510 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
48511 return nativeResponseValue;
48513 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48515 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
48516 if(!isWasmInitialized) {
48517 throw new Error("initializeWasm() must be awaited first!");
48519 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
48520 return nativeResponseValue;
48522 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48524 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
48525 if(!isWasmInitialized) {
48526 throw new Error("initializeWasm() must be awaited first!");
48528 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
48529 return nativeResponseValue;
48531 // void InitFeatures_set_taproot_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48533 export function InitFeatures_set_taproot_optional(this_arg: bigint): void {
48534 if(!isWasmInitialized) {
48535 throw new Error("initializeWasm() must be awaited first!");
48537 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_optional(this_arg);
48538 // debug statements here
48540 // void InitFeatures_set_taproot_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48542 export function InitFeatures_set_taproot_required(this_arg: bigint): void {
48543 if(!isWasmInitialized) {
48544 throw new Error("initializeWasm() must be awaited first!");
48546 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_required(this_arg);
48547 // debug statements here
48549 // MUST_USE_RES bool InitFeatures_supports_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48551 export function InitFeatures_supports_taproot(this_arg: bigint): boolean {
48552 if(!isWasmInitialized) {
48553 throw new Error("initializeWasm() must be awaited first!");
48555 const nativeResponseValue = wasm.TS_InitFeatures_supports_taproot(this_arg);
48556 return nativeResponseValue;
48558 // void NodeFeatures_set_taproot_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48560 export function NodeFeatures_set_taproot_optional(this_arg: bigint): void {
48561 if(!isWasmInitialized) {
48562 throw new Error("initializeWasm() must be awaited first!");
48564 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_optional(this_arg);
48565 // debug statements here
48567 // void NodeFeatures_set_taproot_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48569 export function NodeFeatures_set_taproot_required(this_arg: bigint): void {
48570 if(!isWasmInitialized) {
48571 throw new Error("initializeWasm() must be awaited first!");
48573 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_required(this_arg);
48574 // debug statements here
48576 // MUST_USE_RES bool NodeFeatures_supports_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48578 export function NodeFeatures_supports_taproot(this_arg: bigint): boolean {
48579 if(!isWasmInitialized) {
48580 throw new Error("initializeWasm() must be awaited first!");
48582 const nativeResponseValue = wasm.TS_NodeFeatures_supports_taproot(this_arg);
48583 return nativeResponseValue;
48585 // void ChannelTypeFeatures_set_taproot_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48587 export function ChannelTypeFeatures_set_taproot_optional(this_arg: bigint): void {
48588 if(!isWasmInitialized) {
48589 throw new Error("initializeWasm() must be awaited first!");
48591 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_optional(this_arg);
48592 // debug statements here
48594 // void ChannelTypeFeatures_set_taproot_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48596 export function ChannelTypeFeatures_set_taproot_required(this_arg: bigint): void {
48597 if(!isWasmInitialized) {
48598 throw new Error("initializeWasm() must be awaited first!");
48600 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_required(this_arg);
48601 // debug statements here
48603 // MUST_USE_RES bool ChannelTypeFeatures_supports_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48605 export function ChannelTypeFeatures_supports_taproot(this_arg: bigint): boolean {
48606 if(!isWasmInitialized) {
48607 throw new Error("initializeWasm() must be awaited first!");
48609 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_taproot(this_arg);
48610 return nativeResponseValue;
48612 // MUST_USE_RES bool InitFeatures_requires_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48614 export function InitFeatures_requires_taproot(this_arg: bigint): boolean {
48615 if(!isWasmInitialized) {
48616 throw new Error("initializeWasm() must be awaited first!");
48618 const nativeResponseValue = wasm.TS_InitFeatures_requires_taproot(this_arg);
48619 return nativeResponseValue;
48621 // MUST_USE_RES bool NodeFeatures_requires_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48623 export function NodeFeatures_requires_taproot(this_arg: bigint): boolean {
48624 if(!isWasmInitialized) {
48625 throw new Error("initializeWasm() must be awaited first!");
48627 const nativeResponseValue = wasm.TS_NodeFeatures_requires_taproot(this_arg);
48628 return nativeResponseValue;
48630 // MUST_USE_RES bool ChannelTypeFeatures_requires_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48632 export function ChannelTypeFeatures_requires_taproot(this_arg: bigint): boolean {
48633 if(!isWasmInitialized) {
48634 throw new Error("initializeWasm() must be awaited first!");
48636 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_taproot(this_arg);
48637 return nativeResponseValue;
48639 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48641 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
48642 if(!isWasmInitialized) {
48643 throw new Error("initializeWasm() must be awaited first!");
48645 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
48646 // debug statements here
48648 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48650 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
48651 if(!isWasmInitialized) {
48652 throw new Error("initializeWasm() must be awaited first!");
48654 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
48655 // debug statements here
48657 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48659 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
48660 if(!isWasmInitialized) {
48661 throw new Error("initializeWasm() must be awaited first!");
48663 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
48664 return nativeResponseValue;
48666 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48668 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
48669 if(!isWasmInitialized) {
48670 throw new Error("initializeWasm() must be awaited first!");
48672 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
48673 // debug statements here
48675 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48677 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
48678 if(!isWasmInitialized) {
48679 throw new Error("initializeWasm() must be awaited first!");
48681 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
48682 // debug statements here
48684 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48686 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
48687 if(!isWasmInitialized) {
48688 throw new Error("initializeWasm() must be awaited first!");
48690 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
48691 return nativeResponseValue;
48693 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48695 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
48696 if(!isWasmInitialized) {
48697 throw new Error("initializeWasm() must be awaited first!");
48699 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
48700 return nativeResponseValue;
48702 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48704 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
48705 if(!isWasmInitialized) {
48706 throw new Error("initializeWasm() must be awaited first!");
48708 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
48709 return nativeResponseValue;
48711 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48713 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
48714 if(!isWasmInitialized) {
48715 throw new Error("initializeWasm() must be awaited first!");
48717 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
48718 // debug statements here
48720 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48722 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
48723 if(!isWasmInitialized) {
48724 throw new Error("initializeWasm() must be awaited first!");
48726 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
48727 // debug statements here
48729 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48731 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
48732 if(!isWasmInitialized) {
48733 throw new Error("initializeWasm() must be awaited first!");
48735 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
48736 return nativeResponseValue;
48738 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48740 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
48741 if(!isWasmInitialized) {
48742 throw new Error("initializeWasm() must be awaited first!");
48744 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
48745 // debug statements here
48747 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48749 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
48750 if(!isWasmInitialized) {
48751 throw new Error("initializeWasm() must be awaited first!");
48753 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
48754 // debug statements here
48756 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48758 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
48759 if(!isWasmInitialized) {
48760 throw new Error("initializeWasm() must be awaited first!");
48762 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
48763 return nativeResponseValue;
48765 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48767 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
48768 if(!isWasmInitialized) {
48769 throw new Error("initializeWasm() must be awaited first!");
48771 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
48772 return nativeResponseValue;
48774 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48776 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
48777 if(!isWasmInitialized) {
48778 throw new Error("initializeWasm() must be awaited first!");
48780 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
48781 return nativeResponseValue;
48783 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48785 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
48786 if(!isWasmInitialized) {
48787 throw new Error("initializeWasm() must be awaited first!");
48789 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
48790 // debug statements here
48792 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48794 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
48795 if(!isWasmInitialized) {
48796 throw new Error("initializeWasm() must be awaited first!");
48798 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
48799 // debug statements here
48801 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48803 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
48804 if(!isWasmInitialized) {
48805 throw new Error("initializeWasm() must be awaited first!");
48807 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
48808 return nativeResponseValue;
48810 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48812 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
48813 if(!isWasmInitialized) {
48814 throw new Error("initializeWasm() must be awaited first!");
48816 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
48817 // debug statements here
48819 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48821 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
48822 if(!isWasmInitialized) {
48823 throw new Error("initializeWasm() must be awaited first!");
48825 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
48826 // debug statements here
48828 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48830 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
48831 if(!isWasmInitialized) {
48832 throw new Error("initializeWasm() must be awaited first!");
48834 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
48835 return nativeResponseValue;
48837 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48839 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
48840 if(!isWasmInitialized) {
48841 throw new Error("initializeWasm() must be awaited first!");
48843 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
48844 // debug statements here
48846 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48848 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
48849 if(!isWasmInitialized) {
48850 throw new Error("initializeWasm() must be awaited first!");
48852 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
48853 // debug statements here
48855 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48857 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
48858 if(!isWasmInitialized) {
48859 throw new Error("initializeWasm() must be awaited first!");
48861 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
48862 return nativeResponseValue;
48864 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48866 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
48867 if(!isWasmInitialized) {
48868 throw new Error("initializeWasm() must be awaited first!");
48870 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
48871 return nativeResponseValue;
48873 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48875 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
48876 if(!isWasmInitialized) {
48877 throw new Error("initializeWasm() must be awaited first!");
48879 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
48880 return nativeResponseValue;
48882 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48884 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
48885 if(!isWasmInitialized) {
48886 throw new Error("initializeWasm() must be awaited first!");
48888 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
48889 return nativeResponseValue;
48891 // void Bolt11InvoiceFeatures_set_payment_metadata_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48893 export function Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
48894 if(!isWasmInitialized) {
48895 throw new Error("initializeWasm() must be awaited first!");
48897 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg);
48898 // debug statements here
48900 // void Bolt11InvoiceFeatures_set_payment_metadata_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48902 export function Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
48903 if(!isWasmInitialized) {
48904 throw new Error("initializeWasm() must be awaited first!");
48906 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg);
48907 // debug statements here
48909 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48911 export function Bolt11InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
48912 if(!isWasmInitialized) {
48913 throw new Error("initializeWasm() must be awaited first!");
48915 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_metadata(this_arg);
48916 return nativeResponseValue;
48918 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
48920 export function Bolt11InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
48921 if(!isWasmInitialized) {
48922 throw new Error("initializeWasm() must be awaited first!");
48924 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_metadata(this_arg);
48925 return nativeResponseValue;
48927 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
48929 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
48930 if(!isWasmInitialized) {
48931 throw new Error("initializeWasm() must be awaited first!");
48933 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
48934 // debug statements here
48936 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
48938 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
48939 if(!isWasmInitialized) {
48940 throw new Error("initializeWasm() must be awaited first!");
48942 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
48943 // debug statements here
48945 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
48947 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
48948 if(!isWasmInitialized) {
48949 throw new Error("initializeWasm() must be awaited first!");
48951 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
48952 return nativeResponseValue;
48954 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48956 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
48957 if(!isWasmInitialized) {
48958 throw new Error("initializeWasm() must be awaited first!");
48960 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
48961 // debug statements here
48963 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
48965 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
48966 if(!isWasmInitialized) {
48967 throw new Error("initializeWasm() must be awaited first!");
48969 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
48970 // debug statements here
48972 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
48974 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
48975 if(!isWasmInitialized) {
48976 throw new Error("initializeWasm() must be awaited first!");
48978 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
48979 return nativeResponseValue;
48981 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48983 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
48984 if(!isWasmInitialized) {
48985 throw new Error("initializeWasm() must be awaited first!");
48987 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
48988 // debug statements here
48990 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
48992 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
48993 if(!isWasmInitialized) {
48994 throw new Error("initializeWasm() must be awaited first!");
48996 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
48997 // debug statements here
48999 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
49001 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
49002 if(!isWasmInitialized) {
49003 throw new Error("initializeWasm() must be awaited first!");
49005 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
49006 return nativeResponseValue;
49008 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
49010 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
49011 if(!isWasmInitialized) {
49012 throw new Error("initializeWasm() must be awaited first!");
49014 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
49015 return nativeResponseValue;
49017 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
49019 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
49020 if(!isWasmInitialized) {
49021 throw new Error("initializeWasm() must be awaited first!");
49023 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
49024 return nativeResponseValue;
49026 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
49028 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
49029 if(!isWasmInitialized) {
49030 throw new Error("initializeWasm() must be awaited first!");
49032 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
49033 return nativeResponseValue;
49035 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
49037 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
49038 if(!isWasmInitialized) {
49039 throw new Error("initializeWasm() must be awaited first!");
49041 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
49042 // debug statements here
49044 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
49046 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
49047 if(!isWasmInitialized) {
49048 throw new Error("initializeWasm() must be awaited first!");
49050 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
49051 // debug statements here
49053 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
49055 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
49056 if(!isWasmInitialized) {
49057 throw new Error("initializeWasm() must be awaited first!");
49059 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
49060 return nativeResponseValue;
49062 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
49064 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
49065 if(!isWasmInitialized) {
49066 throw new Error("initializeWasm() must be awaited first!");
49068 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
49069 return nativeResponseValue;
49071 // void InitFeatures_set_trampoline_routing_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
49073 export function InitFeatures_set_trampoline_routing_optional(this_arg: bigint): void {
49074 if(!isWasmInitialized) {
49075 throw new Error("initializeWasm() must be awaited first!");
49077 const nativeResponseValue = wasm.TS_InitFeatures_set_trampoline_routing_optional(this_arg);
49078 // debug statements here
49080 // void InitFeatures_set_trampoline_routing_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
49082 export function InitFeatures_set_trampoline_routing_required(this_arg: bigint): void {
49083 if(!isWasmInitialized) {
49084 throw new Error("initializeWasm() must be awaited first!");
49086 const nativeResponseValue = wasm.TS_InitFeatures_set_trampoline_routing_required(this_arg);
49087 // debug statements here
49089 // MUST_USE_RES bool InitFeatures_supports_trampoline_routing(const struct LDKInitFeatures *NONNULL_PTR this_arg);
49091 export function InitFeatures_supports_trampoline_routing(this_arg: bigint): boolean {
49092 if(!isWasmInitialized) {
49093 throw new Error("initializeWasm() must be awaited first!");
49095 const nativeResponseValue = wasm.TS_InitFeatures_supports_trampoline_routing(this_arg);
49096 return nativeResponseValue;
49098 // void NodeFeatures_set_trampoline_routing_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
49100 export function NodeFeatures_set_trampoline_routing_optional(this_arg: bigint): void {
49101 if(!isWasmInitialized) {
49102 throw new Error("initializeWasm() must be awaited first!");
49104 const nativeResponseValue = wasm.TS_NodeFeatures_set_trampoline_routing_optional(this_arg);
49105 // debug statements here
49107 // void NodeFeatures_set_trampoline_routing_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
49109 export function NodeFeatures_set_trampoline_routing_required(this_arg: bigint): void {
49110 if(!isWasmInitialized) {
49111 throw new Error("initializeWasm() must be awaited first!");
49113 const nativeResponseValue = wasm.TS_NodeFeatures_set_trampoline_routing_required(this_arg);
49114 // debug statements here
49116 // MUST_USE_RES bool NodeFeatures_supports_trampoline_routing(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
49118 export function NodeFeatures_supports_trampoline_routing(this_arg: bigint): boolean {
49119 if(!isWasmInitialized) {
49120 throw new Error("initializeWasm() must be awaited first!");
49122 const nativeResponseValue = wasm.TS_NodeFeatures_supports_trampoline_routing(this_arg);
49123 return nativeResponseValue;
49125 // void Bolt11InvoiceFeatures_set_trampoline_routing_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
49127 export function Bolt11InvoiceFeatures_set_trampoline_routing_optional(this_arg: bigint): void {
49128 if(!isWasmInitialized) {
49129 throw new Error("initializeWasm() must be awaited first!");
49131 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_trampoline_routing_optional(this_arg);
49132 // debug statements here
49134 // void Bolt11InvoiceFeatures_set_trampoline_routing_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
49136 export function Bolt11InvoiceFeatures_set_trampoline_routing_required(this_arg: bigint): void {
49137 if(!isWasmInitialized) {
49138 throw new Error("initializeWasm() must be awaited first!");
49140 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_trampoline_routing_required(this_arg);
49141 // debug statements here
49143 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_trampoline_routing(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
49145 export function Bolt11InvoiceFeatures_supports_trampoline_routing(this_arg: bigint): boolean {
49146 if(!isWasmInitialized) {
49147 throw new Error("initializeWasm() must be awaited first!");
49149 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_trampoline_routing(this_arg);
49150 return nativeResponseValue;
49152 // MUST_USE_RES bool InitFeatures_requires_trampoline_routing(const struct LDKInitFeatures *NONNULL_PTR this_arg);
49154 export function InitFeatures_requires_trampoline_routing(this_arg: bigint): boolean {
49155 if(!isWasmInitialized) {
49156 throw new Error("initializeWasm() must be awaited first!");
49158 const nativeResponseValue = wasm.TS_InitFeatures_requires_trampoline_routing(this_arg);
49159 return nativeResponseValue;
49161 // MUST_USE_RES bool NodeFeatures_requires_trampoline_routing(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
49163 export function NodeFeatures_requires_trampoline_routing(this_arg: bigint): boolean {
49164 if(!isWasmInitialized) {
49165 throw new Error("initializeWasm() must be awaited first!");
49167 const nativeResponseValue = wasm.TS_NodeFeatures_requires_trampoline_routing(this_arg);
49168 return nativeResponseValue;
49170 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_trampoline_routing(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
49172 export function Bolt11InvoiceFeatures_requires_trampoline_routing(this_arg: bigint): boolean {
49173 if(!isWasmInitialized) {
49174 throw new Error("initializeWasm() must be awaited first!");
49176 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_trampoline_routing(this_arg);
49177 return nativeResponseValue;
49179 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
49181 export function ShutdownScript_free(this_obj: bigint): void {
49182 if(!isWasmInitialized) {
49183 throw new Error("initializeWasm() must be awaited first!");
49185 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
49186 // debug statements here
49188 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
49190 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
49191 if(!isWasmInitialized) {
49192 throw new Error("initializeWasm() must be awaited first!");
49194 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
49195 return nativeResponseValue;
49197 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
49199 export function ShutdownScript_clone(orig: bigint): bigint {
49200 if(!isWasmInitialized) {
49201 throw new Error("initializeWasm() must be awaited first!");
49203 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
49204 return nativeResponseValue;
49206 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
49208 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
49209 if(!isWasmInitialized) {
49210 throw new Error("initializeWasm() must be awaited first!");
49212 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
49213 return nativeResponseValue;
49215 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
49217 export function InvalidShutdownScript_free(this_obj: bigint): void {
49218 if(!isWasmInitialized) {
49219 throw new Error("initializeWasm() must be awaited first!");
49221 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
49222 // debug statements here
49224 // struct LDKCVec_u8Z InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
49226 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
49227 if(!isWasmInitialized) {
49228 throw new Error("initializeWasm() must be awaited first!");
49230 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
49231 return nativeResponseValue;
49233 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
49235 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
49236 if(!isWasmInitialized) {
49237 throw new Error("initializeWasm() must be awaited first!");
49239 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
49240 // debug statements here
49242 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
49244 export function InvalidShutdownScript_new(script_arg: number): bigint {
49245 if(!isWasmInitialized) {
49246 throw new Error("initializeWasm() must be awaited first!");
49248 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
49249 return nativeResponseValue;
49251 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
49253 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
49254 if(!isWasmInitialized) {
49255 throw new Error("initializeWasm() must be awaited first!");
49257 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
49258 return nativeResponseValue;
49260 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
49262 export function InvalidShutdownScript_clone(orig: bigint): bigint {
49263 if(!isWasmInitialized) {
49264 throw new Error("initializeWasm() must be awaited first!");
49266 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
49267 return nativeResponseValue;
49269 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
49271 export function ShutdownScript_write(obj: bigint): number {
49272 if(!isWasmInitialized) {
49273 throw new Error("initializeWasm() must be awaited first!");
49275 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
49276 return nativeResponseValue;
49278 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
49280 export function ShutdownScript_read(ser: number): bigint {
49281 if(!isWasmInitialized) {
49282 throw new Error("initializeWasm() must be awaited first!");
49284 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
49285 return nativeResponseValue;
49287 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
49289 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
49290 if(!isWasmInitialized) {
49291 throw new Error("initializeWasm() must be awaited first!");
49293 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
49294 return nativeResponseValue;
49296 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
49298 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
49299 if(!isWasmInitialized) {
49300 throw new Error("initializeWasm() must be awaited first!");
49302 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
49303 return nativeResponseValue;
49305 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessProgram witness_program);
49307 export function ShutdownScript_new_witness_program(witness_program: bigint): bigint {
49308 if(!isWasmInitialized) {
49309 throw new Error("initializeWasm() must be awaited first!");
49311 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(witness_program);
49312 return nativeResponseValue;
49314 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
49316 export function ShutdownScript_into_inner(this_arg: bigint): number {
49317 if(!isWasmInitialized) {
49318 throw new Error("initializeWasm() must be awaited first!");
49320 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
49321 return nativeResponseValue;
49323 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
49325 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
49326 if(!isWasmInitialized) {
49327 throw new Error("initializeWasm() must be awaited first!");
49329 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
49330 return nativeResponseValue;
49332 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
49334 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
49335 if(!isWasmInitialized) {
49336 throw new Error("initializeWasm() must be awaited first!");
49338 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
49339 return nativeResponseValue;
49341 // void ChannelId_free(struct LDKChannelId this_obj);
49343 export function ChannelId_free(this_obj: bigint): void {
49344 if(!isWasmInitialized) {
49345 throw new Error("initializeWasm() must be awaited first!");
49347 const nativeResponseValue = wasm.TS_ChannelId_free(this_obj);
49348 // debug statements here
49350 // const uint8_t (*ChannelId_get_a(const struct LDKChannelId *NONNULL_PTR this_ptr))[32];
49352 export function ChannelId_get_a(this_ptr: bigint): number {
49353 if(!isWasmInitialized) {
49354 throw new Error("initializeWasm() must be awaited first!");
49356 const nativeResponseValue = wasm.TS_ChannelId_get_a(this_ptr);
49357 return nativeResponseValue;
49359 // void ChannelId_set_a(struct LDKChannelId *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49361 export function ChannelId_set_a(this_ptr: bigint, val: number): void {
49362 if(!isWasmInitialized) {
49363 throw new Error("initializeWasm() must be awaited first!");
49365 const nativeResponseValue = wasm.TS_ChannelId_set_a(this_ptr, val);
49366 // debug statements here
49368 // MUST_USE_RES struct LDKChannelId ChannelId_new(struct LDKThirtyTwoBytes a_arg);
49370 export function ChannelId_new(a_arg: number): bigint {
49371 if(!isWasmInitialized) {
49372 throw new Error("initializeWasm() must be awaited first!");
49374 const nativeResponseValue = wasm.TS_ChannelId_new(a_arg);
49375 return nativeResponseValue;
49377 // uint64_t ChannelId_clone_ptr(LDKChannelId *NONNULL_PTR arg);
49379 export function ChannelId_clone_ptr(arg: bigint): bigint {
49380 if(!isWasmInitialized) {
49381 throw new Error("initializeWasm() must be awaited first!");
49383 const nativeResponseValue = wasm.TS_ChannelId_clone_ptr(arg);
49384 return nativeResponseValue;
49386 // struct LDKChannelId ChannelId_clone(const struct LDKChannelId *NONNULL_PTR orig);
49388 export function ChannelId_clone(orig: bigint): bigint {
49389 if(!isWasmInitialized) {
49390 throw new Error("initializeWasm() must be awaited first!");
49392 const nativeResponseValue = wasm.TS_ChannelId_clone(orig);
49393 return nativeResponseValue;
49395 // bool ChannelId_eq(const struct LDKChannelId *NONNULL_PTR a, const struct LDKChannelId *NONNULL_PTR b);
49397 export function ChannelId_eq(a: bigint, b: bigint): boolean {
49398 if(!isWasmInitialized) {
49399 throw new Error("initializeWasm() must be awaited first!");
49401 const nativeResponseValue = wasm.TS_ChannelId_eq(a, b);
49402 return nativeResponseValue;
49404 // uint64_t ChannelId_hash(const struct LDKChannelId *NONNULL_PTR o);
49406 export function ChannelId_hash(o: bigint): bigint {
49407 if(!isWasmInitialized) {
49408 throw new Error("initializeWasm() must be awaited first!");
49410 const nativeResponseValue = wasm.TS_ChannelId_hash(o);
49411 return nativeResponseValue;
49413 // MUST_USE_RES struct LDKChannelId ChannelId_v1_from_funding_txid(const uint8_t (*txid)[32], uint16_t output_index);
49415 export function ChannelId_v1_from_funding_txid(txid: number, output_index: number): bigint {
49416 if(!isWasmInitialized) {
49417 throw new Error("initializeWasm() must be awaited first!");
49419 const nativeResponseValue = wasm.TS_ChannelId_v1_from_funding_txid(txid, output_index);
49420 return nativeResponseValue;
49422 // MUST_USE_RES struct LDKChannelId ChannelId_v1_from_funding_outpoint(struct LDKOutPoint outpoint);
49424 export function ChannelId_v1_from_funding_outpoint(outpoint: bigint): bigint {
49425 if(!isWasmInitialized) {
49426 throw new Error("initializeWasm() must be awaited first!");
49428 const nativeResponseValue = wasm.TS_ChannelId_v1_from_funding_outpoint(outpoint);
49429 return nativeResponseValue;
49431 // MUST_USE_RES struct LDKChannelId ChannelId_temporary_from_entropy_source(const struct LDKEntropySource *NONNULL_PTR entropy_source);
49433 export function ChannelId_temporary_from_entropy_source(entropy_source: bigint): bigint {
49434 if(!isWasmInitialized) {
49435 throw new Error("initializeWasm() must be awaited first!");
49437 const nativeResponseValue = wasm.TS_ChannelId_temporary_from_entropy_source(entropy_source);
49438 return nativeResponseValue;
49440 // MUST_USE_RES struct LDKChannelId ChannelId_from_bytes(struct LDKThirtyTwoBytes data);
49442 export function ChannelId_from_bytes(data: number): bigint {
49443 if(!isWasmInitialized) {
49444 throw new Error("initializeWasm() must be awaited first!");
49446 const nativeResponseValue = wasm.TS_ChannelId_from_bytes(data);
49447 return nativeResponseValue;
49449 // MUST_USE_RES struct LDKChannelId ChannelId_new_zero(void);
49451 export function ChannelId_new_zero(): bigint {
49452 if(!isWasmInitialized) {
49453 throw new Error("initializeWasm() must be awaited first!");
49455 const nativeResponseValue = wasm.TS_ChannelId_new_zero();
49456 return nativeResponseValue;
49458 // MUST_USE_RES bool ChannelId_is_zero(const struct LDKChannelId *NONNULL_PTR this_arg);
49460 export function ChannelId_is_zero(this_arg: bigint): boolean {
49461 if(!isWasmInitialized) {
49462 throw new Error("initializeWasm() must be awaited first!");
49464 const nativeResponseValue = wasm.TS_ChannelId_is_zero(this_arg);
49465 return nativeResponseValue;
49467 // MUST_USE_RES struct LDKChannelId ChannelId_v2_from_revocation_basepoints(const struct LDKRevocationBasepoint *NONNULL_PTR ours, const struct LDKRevocationBasepoint *NONNULL_PTR theirs);
49469 export function ChannelId_v2_from_revocation_basepoints(ours: bigint, theirs: bigint): bigint {
49470 if(!isWasmInitialized) {
49471 throw new Error("initializeWasm() must be awaited first!");
49473 const nativeResponseValue = wasm.TS_ChannelId_v2_from_revocation_basepoints(ours, theirs);
49474 return nativeResponseValue;
49476 // MUST_USE_RES struct LDKChannelId ChannelId_temporary_v2_from_revocation_basepoint(const struct LDKRevocationBasepoint *NONNULL_PTR our_revocation_basepoint);
49478 export function ChannelId_temporary_v2_from_revocation_basepoint(our_revocation_basepoint: bigint): bigint {
49479 if(!isWasmInitialized) {
49480 throw new Error("initializeWasm() must be awaited first!");
49482 const nativeResponseValue = wasm.TS_ChannelId_temporary_v2_from_revocation_basepoint(our_revocation_basepoint);
49483 return nativeResponseValue;
49485 // struct LDKCVec_u8Z ChannelId_write(const struct LDKChannelId *NONNULL_PTR obj);
49487 export function ChannelId_write(obj: bigint): number {
49488 if(!isWasmInitialized) {
49489 throw new Error("initializeWasm() must be awaited first!");
49491 const nativeResponseValue = wasm.TS_ChannelId_write(obj);
49492 return nativeResponseValue;
49494 // struct LDKCResult_ChannelIdDecodeErrorZ ChannelId_read(struct LDKu8slice ser);
49496 export function ChannelId_read(ser: number): bigint {
49497 if(!isWasmInitialized) {
49498 throw new Error("initializeWasm() must be awaited first!");
49500 const nativeResponseValue = wasm.TS_ChannelId_read(ser);
49501 return nativeResponseValue;
49503 // void Retry_free(struct LDKRetry this_ptr);
49505 export function Retry_free(this_ptr: bigint): void {
49506 if(!isWasmInitialized) {
49507 throw new Error("initializeWasm() must be awaited first!");
49509 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
49510 // debug statements here
49512 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
49514 export function Retry_clone_ptr(arg: bigint): bigint {
49515 if(!isWasmInitialized) {
49516 throw new Error("initializeWasm() must be awaited first!");
49518 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
49519 return nativeResponseValue;
49521 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
49523 export function Retry_clone(orig: bigint): bigint {
49524 if(!isWasmInitialized) {
49525 throw new Error("initializeWasm() must be awaited first!");
49527 const nativeResponseValue = wasm.TS_Retry_clone(orig);
49528 return nativeResponseValue;
49530 // struct LDKRetry Retry_attempts(uint32_t a);
49532 export function Retry_attempts(a: number): bigint {
49533 if(!isWasmInitialized) {
49534 throw new Error("initializeWasm() must be awaited first!");
49536 const nativeResponseValue = wasm.TS_Retry_attempts(a);
49537 return nativeResponseValue;
49539 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
49541 export function Retry_eq(a: bigint, b: bigint): boolean {
49542 if(!isWasmInitialized) {
49543 throw new Error("initializeWasm() must be awaited first!");
49545 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
49546 return nativeResponseValue;
49548 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
49550 export function Retry_hash(o: bigint): bigint {
49551 if(!isWasmInitialized) {
49552 throw new Error("initializeWasm() must be awaited first!");
49554 const nativeResponseValue = wasm.TS_Retry_hash(o);
49555 return nativeResponseValue;
49557 // struct LDKCVec_u8Z Retry_write(const struct LDKRetry *NONNULL_PTR obj);
49559 export function Retry_write(obj: bigint): number {
49560 if(!isWasmInitialized) {
49561 throw new Error("initializeWasm() must be awaited first!");
49563 const nativeResponseValue = wasm.TS_Retry_write(obj);
49564 return nativeResponseValue;
49566 // struct LDKCResult_RetryDecodeErrorZ Retry_read(struct LDKu8slice ser);
49568 export function Retry_read(ser: number): bigint {
49569 if(!isWasmInitialized) {
49570 throw new Error("initializeWasm() must be awaited first!");
49572 const nativeResponseValue = wasm.TS_Retry_read(ser);
49573 return nativeResponseValue;
49575 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
49577 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
49578 if(!isWasmInitialized) {
49579 throw new Error("initializeWasm() must be awaited first!");
49581 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
49582 return nativeResponseValue;
49584 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
49586 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
49587 if(!isWasmInitialized) {
49588 throw new Error("initializeWasm() must be awaited first!");
49590 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
49591 return nativeResponseValue;
49593 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
49595 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
49596 if(!isWasmInitialized) {
49597 throw new Error("initializeWasm() must be awaited first!");
49599 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
49600 return nativeResponseValue;
49602 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
49604 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
49605 if(!isWasmInitialized) {
49606 throw new Error("initializeWasm() must be awaited first!");
49608 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
49609 return nativeResponseValue;
49611 // bool RetryableSendFailure_eq(const enum LDKRetryableSendFailure *NONNULL_PTR a, const enum LDKRetryableSendFailure *NONNULL_PTR b);
49613 export function RetryableSendFailure_eq(a: bigint, b: bigint): boolean {
49614 if(!isWasmInitialized) {
49615 throw new Error("initializeWasm() must be awaited first!");
49617 const nativeResponseValue = wasm.TS_RetryableSendFailure_eq(a, b);
49618 return nativeResponseValue;
49620 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
49622 export function PaymentSendFailure_free(this_ptr: bigint): void {
49623 if(!isWasmInitialized) {
49624 throw new Error("initializeWasm() must be awaited first!");
49626 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
49627 // debug statements here
49629 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
49631 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
49632 if(!isWasmInitialized) {
49633 throw new Error("initializeWasm() must be awaited first!");
49635 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
49636 return nativeResponseValue;
49638 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
49640 export function PaymentSendFailure_clone(orig: bigint): bigint {
49641 if(!isWasmInitialized) {
49642 throw new Error("initializeWasm() must be awaited first!");
49644 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
49645 return nativeResponseValue;
49647 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
49649 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
49650 if(!isWasmInitialized) {
49651 throw new Error("initializeWasm() must be awaited first!");
49653 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
49654 return nativeResponseValue;
49656 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
49658 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
49659 if(!isWasmInitialized) {
49660 throw new Error("initializeWasm() must be awaited first!");
49662 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
49663 return nativeResponseValue;
49665 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
49667 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
49668 if(!isWasmInitialized) {
49669 throw new Error("initializeWasm() must be awaited first!");
49671 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
49672 return nativeResponseValue;
49674 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
49676 export function PaymentSendFailure_duplicate_payment(): bigint {
49677 if(!isWasmInitialized) {
49678 throw new Error("initializeWasm() must be awaited first!");
49680 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
49681 return nativeResponseValue;
49683 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
49685 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
49686 if(!isWasmInitialized) {
49687 throw new Error("initializeWasm() must be awaited first!");
49689 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
49690 return nativeResponseValue;
49692 // bool PaymentSendFailure_eq(const struct LDKPaymentSendFailure *NONNULL_PTR a, const struct LDKPaymentSendFailure *NONNULL_PTR b);
49694 export function PaymentSendFailure_eq(a: bigint, b: bigint): boolean {
49695 if(!isWasmInitialized) {
49696 throw new Error("initializeWasm() must be awaited first!");
49698 const nativeResponseValue = wasm.TS_PaymentSendFailure_eq(a, b);
49699 return nativeResponseValue;
49701 // void ProbeSendFailure_free(struct LDKProbeSendFailure this_ptr);
49703 export function ProbeSendFailure_free(this_ptr: bigint): void {
49704 if(!isWasmInitialized) {
49705 throw new Error("initializeWasm() must be awaited first!");
49707 const nativeResponseValue = wasm.TS_ProbeSendFailure_free(this_ptr);
49708 // debug statements here
49710 // uint64_t ProbeSendFailure_clone_ptr(LDKProbeSendFailure *NONNULL_PTR arg);
49712 export function ProbeSendFailure_clone_ptr(arg: bigint): bigint {
49713 if(!isWasmInitialized) {
49714 throw new Error("initializeWasm() must be awaited first!");
49716 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone_ptr(arg);
49717 return nativeResponseValue;
49719 // struct LDKProbeSendFailure ProbeSendFailure_clone(const struct LDKProbeSendFailure *NONNULL_PTR orig);
49721 export function ProbeSendFailure_clone(orig: bigint): bigint {
49722 if(!isWasmInitialized) {
49723 throw new Error("initializeWasm() must be awaited first!");
49725 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone(orig);
49726 return nativeResponseValue;
49728 // struct LDKProbeSendFailure ProbeSendFailure_route_not_found(void);
49730 export function ProbeSendFailure_route_not_found(): bigint {
49731 if(!isWasmInitialized) {
49732 throw new Error("initializeWasm() must be awaited first!");
49734 const nativeResponseValue = wasm.TS_ProbeSendFailure_route_not_found();
49735 return nativeResponseValue;
49737 // struct LDKProbeSendFailure ProbeSendFailure_sending_failed(struct LDKPaymentSendFailure a);
49739 export function ProbeSendFailure_sending_failed(a: bigint): bigint {
49740 if(!isWasmInitialized) {
49741 throw new Error("initializeWasm() must be awaited first!");
49743 const nativeResponseValue = wasm.TS_ProbeSendFailure_sending_failed(a);
49744 return nativeResponseValue;
49746 // bool ProbeSendFailure_eq(const struct LDKProbeSendFailure *NONNULL_PTR a, const struct LDKProbeSendFailure *NONNULL_PTR b);
49748 export function ProbeSendFailure_eq(a: bigint, b: bigint): boolean {
49749 if(!isWasmInitialized) {
49750 throw new Error("initializeWasm() must be awaited first!");
49752 const nativeResponseValue = wasm.TS_ProbeSendFailure_eq(a, b);
49753 return nativeResponseValue;
49755 // void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
49757 export function RecipientOnionFields_free(this_obj: bigint): void {
49758 if(!isWasmInitialized) {
49759 throw new Error("initializeWasm() must be awaited first!");
49761 const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
49762 // debug statements here
49764 // struct LDKCOption_ThirtyTwoBytesZ RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
49766 export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): bigint {
49767 if(!isWasmInitialized) {
49768 throw new Error("initializeWasm() must be awaited first!");
49770 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
49771 return nativeResponseValue;
49773 // void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
49775 export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: bigint): void {
49776 if(!isWasmInitialized) {
49777 throw new Error("initializeWasm() must be awaited first!");
49779 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
49780 // debug statements here
49782 // struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
49784 export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
49785 if(!isWasmInitialized) {
49786 throw new Error("initializeWasm() must be awaited first!");
49788 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
49789 return nativeResponseValue;
49791 // void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
49793 export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
49794 if(!isWasmInitialized) {
49795 throw new Error("initializeWasm() must be awaited first!");
49797 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
49798 // debug statements here
49800 // uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
49802 export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
49803 if(!isWasmInitialized) {
49804 throw new Error("initializeWasm() must be awaited first!");
49806 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
49807 return nativeResponseValue;
49809 // struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
49811 export function RecipientOnionFields_clone(orig: bigint): bigint {
49812 if(!isWasmInitialized) {
49813 throw new Error("initializeWasm() must be awaited first!");
49815 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
49816 return nativeResponseValue;
49818 // bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
49820 export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
49821 if(!isWasmInitialized) {
49822 throw new Error("initializeWasm() must be awaited first!");
49824 const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
49825 return nativeResponseValue;
49827 // struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
49829 export function RecipientOnionFields_write(obj: bigint): number {
49830 if(!isWasmInitialized) {
49831 throw new Error("initializeWasm() must be awaited first!");
49833 const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
49834 return nativeResponseValue;
49836 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
49838 export function RecipientOnionFields_read(ser: number): bigint {
49839 if(!isWasmInitialized) {
49840 throw new Error("initializeWasm() must be awaited first!");
49842 const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
49843 return nativeResponseValue;
49845 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
49847 export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
49848 if(!isWasmInitialized) {
49849 throw new Error("initializeWasm() must be awaited first!");
49851 const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
49852 return nativeResponseValue;
49854 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
49856 export function RecipientOnionFields_spontaneous_empty(): bigint {
49857 if(!isWasmInitialized) {
49858 throw new Error("initializeWasm() must be awaited first!");
49860 const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
49861 return nativeResponseValue;
49863 // MUST_USE_RES struct LDKCResult_RecipientOnionFieldsNoneZ RecipientOnionFields_with_custom_tlvs(struct LDKRecipientOnionFields this_arg, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs);
49865 export function RecipientOnionFields_with_custom_tlvs(this_arg: bigint, custom_tlvs: number): bigint {
49866 if(!isWasmInitialized) {
49867 throw new Error("initializeWasm() must be awaited first!");
49869 const nativeResponseValue = wasm.TS_RecipientOnionFields_with_custom_tlvs(this_arg, custom_tlvs);
49870 return nativeResponseValue;
49872 // MUST_USE_RES struct LDKCVec_C2Tuple_u64CVec_u8ZZZ RecipientOnionFields_custom_tlvs(const struct LDKRecipientOnionFields *NONNULL_PTR this_arg);
49874 export function RecipientOnionFields_custom_tlvs(this_arg: bigint): number {
49875 if(!isWasmInitialized) {
49876 throw new Error("initializeWasm() must be awaited first!");
49878 const nativeResponseValue = wasm.TS_RecipientOnionFields_custom_tlvs(this_arg);
49879 return nativeResponseValue;
49881 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
49883 export function CustomMessageReader_free(this_ptr: bigint): void {
49884 if(!isWasmInitialized) {
49885 throw new Error("initializeWasm() must be awaited first!");
49887 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
49888 // debug statements here
49890 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
49892 export function Type_clone_ptr(arg: bigint): bigint {
49893 if(!isWasmInitialized) {
49894 throw new Error("initializeWasm() must be awaited first!");
49896 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
49897 return nativeResponseValue;
49899 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
49901 export function Type_clone(orig: bigint): bigint {
49902 if(!isWasmInitialized) {
49903 throw new Error("initializeWasm() must be awaited first!");
49905 const nativeResponseValue = wasm.TS_Type_clone(orig);
49906 return nativeResponseValue;
49908 // void Type_free(struct LDKType this_ptr);
49910 export function Type_free(this_ptr: bigint): void {
49911 if(!isWasmInitialized) {
49912 throw new Error("initializeWasm() must be awaited first!");
49914 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
49915 // debug statements here
49917 // void OfferId_free(struct LDKOfferId this_obj);
49919 export function OfferId_free(this_obj: bigint): void {
49920 if(!isWasmInitialized) {
49921 throw new Error("initializeWasm() must be awaited first!");
49923 const nativeResponseValue = wasm.TS_OfferId_free(this_obj);
49924 // debug statements here
49926 // const uint8_t (*OfferId_get_a(const struct LDKOfferId *NONNULL_PTR this_ptr))[32];
49928 export function OfferId_get_a(this_ptr: bigint): number {
49929 if(!isWasmInitialized) {
49930 throw new Error("initializeWasm() must be awaited first!");
49932 const nativeResponseValue = wasm.TS_OfferId_get_a(this_ptr);
49933 return nativeResponseValue;
49935 // void OfferId_set_a(struct LDKOfferId *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49937 export function OfferId_set_a(this_ptr: bigint, val: number): void {
49938 if(!isWasmInitialized) {
49939 throw new Error("initializeWasm() must be awaited first!");
49941 const nativeResponseValue = wasm.TS_OfferId_set_a(this_ptr, val);
49942 // debug statements here
49944 // MUST_USE_RES struct LDKOfferId OfferId_new(struct LDKThirtyTwoBytes a_arg);
49946 export function OfferId_new(a_arg: number): bigint {
49947 if(!isWasmInitialized) {
49948 throw new Error("initializeWasm() must be awaited first!");
49950 const nativeResponseValue = wasm.TS_OfferId_new(a_arg);
49951 return nativeResponseValue;
49953 // uint64_t OfferId_clone_ptr(LDKOfferId *NONNULL_PTR arg);
49955 export function OfferId_clone_ptr(arg: bigint): bigint {
49956 if(!isWasmInitialized) {
49957 throw new Error("initializeWasm() must be awaited first!");
49959 const nativeResponseValue = wasm.TS_OfferId_clone_ptr(arg);
49960 return nativeResponseValue;
49962 // struct LDKOfferId OfferId_clone(const struct LDKOfferId *NONNULL_PTR orig);
49964 export function OfferId_clone(orig: bigint): bigint {
49965 if(!isWasmInitialized) {
49966 throw new Error("initializeWasm() must be awaited first!");
49968 const nativeResponseValue = wasm.TS_OfferId_clone(orig);
49969 return nativeResponseValue;
49971 // bool OfferId_eq(const struct LDKOfferId *NONNULL_PTR a, const struct LDKOfferId *NONNULL_PTR b);
49973 export function OfferId_eq(a: bigint, b: bigint): boolean {
49974 if(!isWasmInitialized) {
49975 throw new Error("initializeWasm() must be awaited first!");
49977 const nativeResponseValue = wasm.TS_OfferId_eq(a, b);
49978 return nativeResponseValue;
49980 // struct LDKCVec_u8Z OfferId_write(const struct LDKOfferId *NONNULL_PTR obj);
49982 export function OfferId_write(obj: bigint): number {
49983 if(!isWasmInitialized) {
49984 throw new Error("initializeWasm() must be awaited first!");
49986 const nativeResponseValue = wasm.TS_OfferId_write(obj);
49987 return nativeResponseValue;
49989 // struct LDKCResult_OfferIdDecodeErrorZ OfferId_read(struct LDKu8slice ser);
49991 export function OfferId_read(ser: number): bigint {
49992 if(!isWasmInitialized) {
49993 throw new Error("initializeWasm() must be awaited first!");
49995 const nativeResponseValue = wasm.TS_OfferId_read(ser);
49996 return nativeResponseValue;
49998 // void OfferWithExplicitMetadataBuilder_free(struct LDKOfferWithExplicitMetadataBuilder this_obj);
50000 export function OfferWithExplicitMetadataBuilder_free(this_obj: bigint): void {
50001 if(!isWasmInitialized) {
50002 throw new Error("initializeWasm() must be awaited first!");
50004 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_free(this_obj);
50005 // debug statements here
50007 // uint64_t OfferWithExplicitMetadataBuilder_clone_ptr(LDKOfferWithExplicitMetadataBuilder *NONNULL_PTR arg);
50009 export function OfferWithExplicitMetadataBuilder_clone_ptr(arg: bigint): bigint {
50010 if(!isWasmInitialized) {
50011 throw new Error("initializeWasm() must be awaited first!");
50013 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_clone_ptr(arg);
50014 return nativeResponseValue;
50016 // struct LDKOfferWithExplicitMetadataBuilder OfferWithExplicitMetadataBuilder_clone(const struct LDKOfferWithExplicitMetadataBuilder *NONNULL_PTR orig);
50018 export function OfferWithExplicitMetadataBuilder_clone(orig: bigint): bigint {
50019 if(!isWasmInitialized) {
50020 throw new Error("initializeWasm() must be awaited first!");
50022 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_clone(orig);
50023 return nativeResponseValue;
50025 // void OfferWithDerivedMetadataBuilder_free(struct LDKOfferWithDerivedMetadataBuilder this_obj);
50027 export function OfferWithDerivedMetadataBuilder_free(this_obj: bigint): void {
50028 if(!isWasmInitialized) {
50029 throw new Error("initializeWasm() must be awaited first!");
50031 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_free(this_obj);
50032 // debug statements here
50034 // uint64_t OfferWithDerivedMetadataBuilder_clone_ptr(LDKOfferWithDerivedMetadataBuilder *NONNULL_PTR arg);
50036 export function OfferWithDerivedMetadataBuilder_clone_ptr(arg: bigint): bigint {
50037 if(!isWasmInitialized) {
50038 throw new Error("initializeWasm() must be awaited first!");
50040 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_clone_ptr(arg);
50041 return nativeResponseValue;
50043 // struct LDKOfferWithDerivedMetadataBuilder OfferWithDerivedMetadataBuilder_clone(const struct LDKOfferWithDerivedMetadataBuilder *NONNULL_PTR orig);
50045 export function OfferWithDerivedMetadataBuilder_clone(orig: bigint): bigint {
50046 if(!isWasmInitialized) {
50047 throw new Error("initializeWasm() must be awaited first!");
50049 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_clone(orig);
50050 return nativeResponseValue;
50052 // MUST_USE_RES struct LDKOfferWithExplicitMetadataBuilder OfferWithExplicitMetadataBuilder_new(struct LDKPublicKey signing_pubkey);
50054 export function OfferWithExplicitMetadataBuilder_new(signing_pubkey: number): bigint {
50055 if(!isWasmInitialized) {
50056 throw new Error("initializeWasm() must be awaited first!");
50058 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_new(signing_pubkey);
50059 return nativeResponseValue;
50061 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ OfferWithExplicitMetadataBuilder_metadata(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKCVec_u8Z metadata);
50063 export function OfferWithExplicitMetadataBuilder_metadata(this_arg: bigint, metadata: number): bigint {
50064 if(!isWasmInitialized) {
50065 throw new Error("initializeWasm() must be awaited first!");
50067 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_metadata(this_arg, metadata);
50068 return nativeResponseValue;
50070 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_chain(struct LDKOfferWithExplicitMetadataBuilder this_arg, enum LDKNetwork network);
50072 export function OfferWithExplicitMetadataBuilder_chain(this_arg: bigint, network: Network): void {
50073 if(!isWasmInitialized) {
50074 throw new Error("initializeWasm() must be awaited first!");
50076 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_chain(this_arg, network);
50077 // debug statements here
50079 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_amount_msats(struct LDKOfferWithExplicitMetadataBuilder this_arg, uint64_t amount_msats);
50081 export function OfferWithExplicitMetadataBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): void {
50082 if(!isWasmInitialized) {
50083 throw new Error("initializeWasm() must be awaited first!");
50085 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_amount_msats(this_arg, amount_msats);
50086 // debug statements here
50088 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_absolute_expiry(struct LDKOfferWithExplicitMetadataBuilder this_arg, uint64_t absolute_expiry);
50090 export function OfferWithExplicitMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
50091 if(!isWasmInitialized) {
50092 throw new Error("initializeWasm() must be awaited first!");
50094 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
50095 // debug statements here
50097 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_description(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKStr description);
50099 export function OfferWithExplicitMetadataBuilder_description(this_arg: bigint, description: number): void {
50100 if(!isWasmInitialized) {
50101 throw new Error("initializeWasm() must be awaited first!");
50103 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_description(this_arg, description);
50104 // debug statements here
50106 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_issuer(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKStr issuer);
50108 export function OfferWithExplicitMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
50109 if(!isWasmInitialized) {
50110 throw new Error("initializeWasm() must be awaited first!");
50112 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_issuer(this_arg, issuer);
50113 // debug statements here
50115 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_path(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKBlindedPath path);
50117 export function OfferWithExplicitMetadataBuilder_path(this_arg: bigint, path: bigint): void {
50118 if(!isWasmInitialized) {
50119 throw new Error("initializeWasm() must be awaited first!");
50121 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_path(this_arg, path);
50122 // debug statements here
50124 // MUST_USE_RES void OfferWithExplicitMetadataBuilder_supported_quantity(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKQuantity quantity);
50126 export function OfferWithExplicitMetadataBuilder_supported_quantity(this_arg: bigint, quantity: bigint): void {
50127 if(!isWasmInitialized) {
50128 throw new Error("initializeWasm() must be awaited first!");
50130 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_supported_quantity(this_arg, quantity);
50131 // debug statements here
50133 // MUST_USE_RES struct LDKCResult_OfferBolt12SemanticErrorZ OfferWithExplicitMetadataBuilder_build(struct LDKOfferWithExplicitMetadataBuilder this_arg);
50135 export function OfferWithExplicitMetadataBuilder_build(this_arg: bigint): bigint {
50136 if(!isWasmInitialized) {
50137 throw new Error("initializeWasm() must be awaited first!");
50139 const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_build(this_arg);
50140 return nativeResponseValue;
50142 // MUST_USE_RES struct LDKOfferWithDerivedMetadataBuilder OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(struct LDKPublicKey node_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKEntropySource entropy_source);
50144 export function OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(node_id: number, expanded_key: bigint, entropy_source: bigint): bigint {
50145 if(!isWasmInitialized) {
50146 throw new Error("initializeWasm() must be awaited first!");
50148 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(node_id, expanded_key, entropy_source);
50149 return nativeResponseValue;
50151 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_chain(struct LDKOfferWithDerivedMetadataBuilder this_arg, enum LDKNetwork network);
50153 export function OfferWithDerivedMetadataBuilder_chain(this_arg: bigint, network: Network): void {
50154 if(!isWasmInitialized) {
50155 throw new Error("initializeWasm() must be awaited first!");
50157 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_chain(this_arg, network);
50158 // debug statements here
50160 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_amount_msats(struct LDKOfferWithDerivedMetadataBuilder this_arg, uint64_t amount_msats);
50162 export function OfferWithDerivedMetadataBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): void {
50163 if(!isWasmInitialized) {
50164 throw new Error("initializeWasm() must be awaited first!");
50166 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_amount_msats(this_arg, amount_msats);
50167 // debug statements here
50169 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_absolute_expiry(struct LDKOfferWithDerivedMetadataBuilder this_arg, uint64_t absolute_expiry);
50171 export function OfferWithDerivedMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
50172 if(!isWasmInitialized) {
50173 throw new Error("initializeWasm() must be awaited first!");
50175 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
50176 // debug statements here
50178 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_description(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKStr description);
50180 export function OfferWithDerivedMetadataBuilder_description(this_arg: bigint, description: number): void {
50181 if(!isWasmInitialized) {
50182 throw new Error("initializeWasm() must be awaited first!");
50184 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_description(this_arg, description);
50185 // debug statements here
50187 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_issuer(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKStr issuer);
50189 export function OfferWithDerivedMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
50190 if(!isWasmInitialized) {
50191 throw new Error("initializeWasm() must be awaited first!");
50193 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_issuer(this_arg, issuer);
50194 // debug statements here
50196 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_path(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKBlindedPath path);
50198 export function OfferWithDerivedMetadataBuilder_path(this_arg: bigint, path: bigint): void {
50199 if(!isWasmInitialized) {
50200 throw new Error("initializeWasm() must be awaited first!");
50202 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_path(this_arg, path);
50203 // debug statements here
50205 // MUST_USE_RES void OfferWithDerivedMetadataBuilder_supported_quantity(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKQuantity quantity);
50207 export function OfferWithDerivedMetadataBuilder_supported_quantity(this_arg: bigint, quantity: bigint): void {
50208 if(!isWasmInitialized) {
50209 throw new Error("initializeWasm() must be awaited first!");
50211 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_supported_quantity(this_arg, quantity);
50212 // debug statements here
50214 // MUST_USE_RES struct LDKCResult_OfferBolt12SemanticErrorZ OfferWithDerivedMetadataBuilder_build(struct LDKOfferWithDerivedMetadataBuilder this_arg);
50216 export function OfferWithDerivedMetadataBuilder_build(this_arg: bigint): bigint {
50217 if(!isWasmInitialized) {
50218 throw new Error("initializeWasm() must be awaited first!");
50220 const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_build(this_arg);
50221 return nativeResponseValue;
50223 // void Offer_free(struct LDKOffer this_obj);
50225 export function Offer_free(this_obj: bigint): void {
50226 if(!isWasmInitialized) {
50227 throw new Error("initializeWasm() must be awaited first!");
50229 const nativeResponseValue = wasm.TS_Offer_free(this_obj);
50230 // debug statements here
50232 // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
50234 export function Offer_clone_ptr(arg: bigint): bigint {
50235 if(!isWasmInitialized) {
50236 throw new Error("initializeWasm() must be awaited first!");
50238 const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
50239 return nativeResponseValue;
50241 // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
50243 export function Offer_clone(orig: bigint): bigint {
50244 if(!isWasmInitialized) {
50245 throw new Error("initializeWasm() must be awaited first!");
50247 const nativeResponseValue = wasm.TS_Offer_clone(orig);
50248 return nativeResponseValue;
50250 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
50252 export function Offer_chains(this_arg: bigint): number {
50253 if(!isWasmInitialized) {
50254 throw new Error("initializeWasm() must be awaited first!");
50256 const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
50257 return nativeResponseValue;
50259 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
50261 export function Offer_metadata(this_arg: bigint): bigint {
50262 if(!isWasmInitialized) {
50263 throw new Error("initializeWasm() must be awaited first!");
50265 const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
50266 return nativeResponseValue;
50268 // MUST_USE_RES struct LDKCOption_AmountZ Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
50270 export function Offer_amount(this_arg: bigint): bigint {
50271 if(!isWasmInitialized) {
50272 throw new Error("initializeWasm() must be awaited first!");
50274 const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
50275 return nativeResponseValue;
50277 // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
50279 export function Offer_description(this_arg: bigint): bigint {
50280 if(!isWasmInitialized) {
50281 throw new Error("initializeWasm() must be awaited first!");
50283 const nativeResponseValue = wasm.TS_Offer_description(this_arg);
50284 return nativeResponseValue;
50286 // MUST_USE_RES struct LDKOfferFeatures Offer_offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
50288 export function Offer_offer_features(this_arg: bigint): bigint {
50289 if(!isWasmInitialized) {
50290 throw new Error("initializeWasm() must be awaited first!");
50292 const nativeResponseValue = wasm.TS_Offer_offer_features(this_arg);
50293 return nativeResponseValue;
50295 // MUST_USE_RES struct LDKCOption_u64Z Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
50297 export function Offer_absolute_expiry(this_arg: bigint): bigint {
50298 if(!isWasmInitialized) {
50299 throw new Error("initializeWasm() must be awaited first!");
50301 const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
50302 return nativeResponseValue;
50304 // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
50306 export function Offer_issuer(this_arg: bigint): bigint {
50307 if(!isWasmInitialized) {
50308 throw new Error("initializeWasm() must be awaited first!");
50310 const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
50311 return nativeResponseValue;
50313 // MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
50315 export function Offer_paths(this_arg: bigint): number {
50316 if(!isWasmInitialized) {
50317 throw new Error("initializeWasm() must be awaited first!");
50319 const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
50320 return nativeResponseValue;
50322 // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
50324 export function Offer_supported_quantity(this_arg: bigint): bigint {
50325 if(!isWasmInitialized) {
50326 throw new Error("initializeWasm() must be awaited first!");
50328 const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
50329 return nativeResponseValue;
50331 // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
50333 export function Offer_signing_pubkey(this_arg: bigint): number {
50334 if(!isWasmInitialized) {
50335 throw new Error("initializeWasm() must be awaited first!");
50337 const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
50338 return nativeResponseValue;
50340 // MUST_USE_RES struct LDKOfferId Offer_id(const struct LDKOffer *NONNULL_PTR this_arg);
50342 export function Offer_id(this_arg: bigint): bigint {
50343 if(!isWasmInitialized) {
50344 throw new Error("initializeWasm() must be awaited first!");
50346 const nativeResponseValue = wasm.TS_Offer_id(this_arg);
50347 return nativeResponseValue;
50349 // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
50351 export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
50352 if(!isWasmInitialized) {
50353 throw new Error("initializeWasm() must be awaited first!");
50355 const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
50356 return nativeResponseValue;
50358 // MUST_USE_RES bool Offer_is_expired_no_std(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
50360 export function Offer_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
50361 if(!isWasmInitialized) {
50362 throw new Error("initializeWasm() must be awaited first!");
50364 const nativeResponseValue = wasm.TS_Offer_is_expired_no_std(this_arg, duration_since_epoch);
50365 return nativeResponseValue;
50367 // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
50369 export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
50370 if(!isWasmInitialized) {
50371 throw new Error("initializeWasm() must be awaited first!");
50373 const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
50374 return nativeResponseValue;
50376 // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
50378 export function Offer_expects_quantity(this_arg: bigint): boolean {
50379 if(!isWasmInitialized) {
50380 throw new Error("initializeWasm() must be awaited first!");
50382 const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
50383 return nativeResponseValue;
50385 // MUST_USE_RES struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice_deriving_payer_id(const struct LDKOffer *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKEntropySource entropy_source, struct LDKThirtyTwoBytes payment_id);
50387 export function Offer_request_invoice_deriving_payer_id(this_arg: bigint, expanded_key: bigint, entropy_source: bigint, payment_id: number): bigint {
50388 if(!isWasmInitialized) {
50389 throw new Error("initializeWasm() must be awaited first!");
50391 const nativeResponseValue = wasm.TS_Offer_request_invoice_deriving_payer_id(this_arg, expanded_key, entropy_source, payment_id);
50392 return nativeResponseValue;
50394 // MUST_USE_RES struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice_deriving_metadata(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKPublicKey payer_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKEntropySource entropy_source, struct LDKThirtyTwoBytes payment_id);
50396 export function Offer_request_invoice_deriving_metadata(this_arg: bigint, payer_id: number, expanded_key: bigint, entropy_source: bigint, payment_id: number): bigint {
50397 if(!isWasmInitialized) {
50398 throw new Error("initializeWasm() must be awaited first!");
50400 const nativeResponseValue = wasm.TS_Offer_request_invoice_deriving_metadata(this_arg, payer_id, expanded_key, entropy_source, payment_id);
50401 return nativeResponseValue;
50403 // MUST_USE_RES struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKCVec_u8Z metadata, struct LDKPublicKey payer_id);
50405 export function Offer_request_invoice(this_arg: bigint, metadata: number, payer_id: number): bigint {
50406 if(!isWasmInitialized) {
50407 throw new Error("initializeWasm() must be awaited first!");
50409 const nativeResponseValue = wasm.TS_Offer_request_invoice(this_arg, metadata, payer_id);
50410 return nativeResponseValue;
50412 // uint64_t Offer_hash(const struct LDKOffer *NONNULL_PTR o);
50414 export function Offer_hash(o: bigint): bigint {
50415 if(!isWasmInitialized) {
50416 throw new Error("initializeWasm() must be awaited first!");
50418 const nativeResponseValue = wasm.TS_Offer_hash(o);
50419 return nativeResponseValue;
50421 // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
50423 export function Offer_write(obj: bigint): number {
50424 if(!isWasmInitialized) {
50425 throw new Error("initializeWasm() must be awaited first!");
50427 const nativeResponseValue = wasm.TS_Offer_write(obj);
50428 return nativeResponseValue;
50430 // void Amount_free(struct LDKAmount this_ptr);
50432 export function Amount_free(this_ptr: bigint): void {
50433 if(!isWasmInitialized) {
50434 throw new Error("initializeWasm() must be awaited first!");
50436 const nativeResponseValue = wasm.TS_Amount_free(this_ptr);
50437 // debug statements here
50439 // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
50441 export function Amount_clone_ptr(arg: bigint): bigint {
50442 if(!isWasmInitialized) {
50443 throw new Error("initializeWasm() must be awaited first!");
50445 const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
50446 return nativeResponseValue;
50448 // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
50450 export function Amount_clone(orig: bigint): bigint {
50451 if(!isWasmInitialized) {
50452 throw new Error("initializeWasm() must be awaited first!");
50454 const nativeResponseValue = wasm.TS_Amount_clone(orig);
50455 return nativeResponseValue;
50457 // struct LDKAmount Amount_bitcoin(uint64_t amount_msats);
50459 export function Amount_bitcoin(amount_msats: bigint): bigint {
50460 if(!isWasmInitialized) {
50461 throw new Error("initializeWasm() must be awaited first!");
50463 const nativeResponseValue = wasm.TS_Amount_bitcoin(amount_msats);
50464 return nativeResponseValue;
50466 // struct LDKAmount Amount_currency(struct LDKThreeBytes iso4217_code, uint64_t amount);
50468 export function Amount_currency(iso4217_code: number, amount: bigint): bigint {
50469 if(!isWasmInitialized) {
50470 throw new Error("initializeWasm() must be awaited first!");
50472 const nativeResponseValue = wasm.TS_Amount_currency(iso4217_code, amount);
50473 return nativeResponseValue;
50475 // void Quantity_free(struct LDKQuantity this_ptr);
50477 export function Quantity_free(this_ptr: bigint): void {
50478 if(!isWasmInitialized) {
50479 throw new Error("initializeWasm() must be awaited first!");
50481 const nativeResponseValue = wasm.TS_Quantity_free(this_ptr);
50482 // debug statements here
50484 // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
50486 export function Quantity_clone_ptr(arg: bigint): bigint {
50487 if(!isWasmInitialized) {
50488 throw new Error("initializeWasm() must be awaited first!");
50490 const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
50491 return nativeResponseValue;
50493 // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
50495 export function Quantity_clone(orig: bigint): bigint {
50496 if(!isWasmInitialized) {
50497 throw new Error("initializeWasm() must be awaited first!");
50499 const nativeResponseValue = wasm.TS_Quantity_clone(orig);
50500 return nativeResponseValue;
50502 // struct LDKQuantity Quantity_bounded(uint64_t a);
50504 export function Quantity_bounded(a: bigint): bigint {
50505 if(!isWasmInitialized) {
50506 throw new Error("initializeWasm() must be awaited first!");
50508 const nativeResponseValue = wasm.TS_Quantity_bounded(a);
50509 return nativeResponseValue;
50511 // struct LDKQuantity Quantity_unbounded(void);
50513 export function Quantity_unbounded(): bigint {
50514 if(!isWasmInitialized) {
50515 throw new Error("initializeWasm() must be awaited first!");
50517 const nativeResponseValue = wasm.TS_Quantity_unbounded();
50518 return nativeResponseValue;
50520 // struct LDKQuantity Quantity_one(void);
50522 export function Quantity_one(): bigint {
50523 if(!isWasmInitialized) {
50524 throw new Error("initializeWasm() must be awaited first!");
50526 const nativeResponseValue = wasm.TS_Quantity_one();
50527 return nativeResponseValue;
50529 // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
50531 export function Offer_from_str(s: number): bigint {
50532 if(!isWasmInitialized) {
50533 throw new Error("initializeWasm() must be awaited first!");
50535 const nativeResponseValue = wasm.TS_Offer_from_str(s);
50536 return nativeResponseValue;
50538 // void InvoiceWithExplicitSigningPubkeyBuilder_free(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_obj);
50540 export function InvoiceWithExplicitSigningPubkeyBuilder_free(this_obj: bigint): void {
50541 if(!isWasmInitialized) {
50542 throw new Error("initializeWasm() must be awaited first!");
50544 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_free(this_obj);
50545 // debug statements here
50547 // void InvoiceWithDerivedSigningPubkeyBuilder_free(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_obj);
50549 export function InvoiceWithDerivedSigningPubkeyBuilder_free(this_obj: bigint): void {
50550 if(!isWasmInitialized) {
50551 throw new Error("initializeWasm() must be awaited first!");
50553 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_free(this_obj);
50554 // debug statements here
50556 // MUST_USE_RES struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ InvoiceWithExplicitSigningPubkeyBuilder_build(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg);
50558 export function InvoiceWithExplicitSigningPubkeyBuilder_build(this_arg: bigint): bigint {
50559 if(!isWasmInitialized) {
50560 throw new Error("initializeWasm() must be awaited first!");
50562 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_build(this_arg);
50563 return nativeResponseValue;
50565 // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, uint32_t relative_expiry_secs);
50567 export function InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(this_arg: bigint, relative_expiry_secs: number): void {
50568 if(!isWasmInitialized) {
50569 throw new Error("initializeWasm() must be awaited first!");
50571 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(this_arg, relative_expiry_secs);
50572 // debug statements here
50574 // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, const uint8_t (*script_hash)[32]);
50576 export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg: bigint, script_hash: number): void {
50577 if(!isWasmInitialized) {
50578 throw new Error("initializeWasm() must be awaited first!");
50580 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg, script_hash);
50581 // debug statements here
50583 // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, const uint8_t (*pubkey_hash)[20]);
50585 export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg: bigint, pubkey_hash: number): void {
50586 if(!isWasmInitialized) {
50587 throw new Error("initializeWasm() must be awaited first!");
50589 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg, pubkey_hash);
50590 // debug statements here
50592 // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, struct LDKTweakedPublicKey output_key);
50594 export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg: bigint, utput_key: number): void {
50595 if(!isWasmInitialized) {
50596 throw new Error("initializeWasm() must be awaited first!");
50598 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg, utput_key);
50599 // debug statements here
50601 // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg);
50603 export function InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(this_arg: bigint): void {
50604 if(!isWasmInitialized) {
50605 throw new Error("initializeWasm() must be awaited first!");
50607 const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(this_arg);
50608 // debug statements here
50610 // MUST_USE_RES struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg);
50612 export function InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(this_arg: bigint): bigint {
50613 if(!isWasmInitialized) {
50614 throw new Error("initializeWasm() must be awaited first!");
50616 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(this_arg);
50617 return nativeResponseValue;
50619 // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, uint32_t relative_expiry_secs);
50621 export function InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(this_arg: bigint, relative_expiry_secs: number): void {
50622 if(!isWasmInitialized) {
50623 throw new Error("initializeWasm() must be awaited first!");
50625 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(this_arg, relative_expiry_secs);
50626 // debug statements here
50628 // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, const uint8_t (*script_hash)[32]);
50630 export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg: bigint, script_hash: number): void {
50631 if(!isWasmInitialized) {
50632 throw new Error("initializeWasm() must be awaited first!");
50634 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg, script_hash);
50635 // debug statements here
50637 // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, const uint8_t (*pubkey_hash)[20]);
50639 export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg: bigint, pubkey_hash: number): void {
50640 if(!isWasmInitialized) {
50641 throw new Error("initializeWasm() must be awaited first!");
50643 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg, pubkey_hash);
50644 // debug statements here
50646 // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, struct LDKTweakedPublicKey output_key);
50648 export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg: bigint, utput_key: number): void {
50649 if(!isWasmInitialized) {
50650 throw new Error("initializeWasm() must be awaited first!");
50652 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg, utput_key);
50653 // debug statements here
50655 // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg);
50657 export function InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(this_arg: bigint): void {
50658 if(!isWasmInitialized) {
50659 throw new Error("initializeWasm() must be awaited first!");
50661 const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(this_arg);
50662 // debug statements here
50664 // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
50666 export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
50667 if(!isWasmInitialized) {
50668 throw new Error("initializeWasm() must be awaited first!");
50670 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
50671 // debug statements here
50673 // uint64_t UnsignedBolt12Invoice_clone_ptr(LDKUnsignedBolt12Invoice *NONNULL_PTR arg);
50675 export function UnsignedBolt12Invoice_clone_ptr(arg: bigint): bigint {
50676 if(!isWasmInitialized) {
50677 throw new Error("initializeWasm() must be awaited first!");
50679 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_clone_ptr(arg);
50680 return nativeResponseValue;
50682 // struct LDKUnsignedBolt12Invoice UnsignedBolt12Invoice_clone(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR orig);
50684 export function UnsignedBolt12Invoice_clone(orig: bigint): bigint {
50685 if(!isWasmInitialized) {
50686 throw new Error("initializeWasm() must be awaited first!");
50688 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_clone(orig);
50689 return nativeResponseValue;
50691 // void SignBolt12InvoiceFn_free(struct LDKSignBolt12InvoiceFn this_ptr);
50693 export function SignBolt12InvoiceFn_free(this_ptr: bigint): void {
50694 if(!isWasmInitialized) {
50695 throw new Error("initializeWasm() must be awaited first!");
50697 const nativeResponseValue = wasm.TS_SignBolt12InvoiceFn_free(this_ptr);
50698 // debug statements here
50700 // MUST_USE_RES struct LDKTaggedHash UnsignedBolt12Invoice_tagged_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50702 export function UnsignedBolt12Invoice_tagged_hash(this_arg: bigint): bigint {
50703 if(!isWasmInitialized) {
50704 throw new Error("initializeWasm() must be awaited first!");
50706 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_tagged_hash(this_arg);
50707 return nativeResponseValue;
50709 // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
50711 export function Bolt12Invoice_free(this_obj: bigint): void {
50712 if(!isWasmInitialized) {
50713 throw new Error("initializeWasm() must be awaited first!");
50715 const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
50716 // debug statements here
50718 // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
50720 export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
50721 if(!isWasmInitialized) {
50722 throw new Error("initializeWasm() must be awaited first!");
50724 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
50725 return nativeResponseValue;
50727 // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
50729 export function Bolt12Invoice_clone(orig: bigint): bigint {
50730 if(!isWasmInitialized) {
50731 throw new Error("initializeWasm() must be awaited first!");
50733 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
50734 return nativeResponseValue;
50736 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ UnsignedBolt12Invoice_offer_chains(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50738 export function UnsignedBolt12Invoice_offer_chains(this_arg: bigint): bigint {
50739 if(!isWasmInitialized) {
50740 throw new Error("initializeWasm() must be awaited first!");
50742 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_chains(this_arg);
50743 return nativeResponseValue;
50745 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_chain(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50747 export function UnsignedBolt12Invoice_chain(this_arg: bigint): number {
50748 if(!isWasmInitialized) {
50749 throw new Error("initializeWasm() must be awaited first!");
50751 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_chain(this_arg);
50752 return nativeResponseValue;
50754 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedBolt12Invoice_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50756 export function UnsignedBolt12Invoice_metadata(this_arg: bigint): bigint {
50757 if(!isWasmInitialized) {
50758 throw new Error("initializeWasm() must be awaited first!");
50760 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_metadata(this_arg);
50761 return nativeResponseValue;
50763 // MUST_USE_RES struct LDKCOption_AmountZ UnsignedBolt12Invoice_amount(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50765 export function UnsignedBolt12Invoice_amount(this_arg: bigint): bigint {
50766 if(!isWasmInitialized) {
50767 throw new Error("initializeWasm() must be awaited first!");
50769 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount(this_arg);
50770 return nativeResponseValue;
50772 // MUST_USE_RES struct LDKOfferFeatures UnsignedBolt12Invoice_offer_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50774 export function UnsignedBolt12Invoice_offer_features(this_arg: bigint): bigint {
50775 if(!isWasmInitialized) {
50776 throw new Error("initializeWasm() must be awaited first!");
50778 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_features(this_arg);
50779 return nativeResponseValue;
50781 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_description(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50783 export function UnsignedBolt12Invoice_description(this_arg: bigint): bigint {
50784 if(!isWasmInitialized) {
50785 throw new Error("initializeWasm() must be awaited first!");
50787 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_description(this_arg);
50788 return nativeResponseValue;
50790 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_absolute_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50792 export function UnsignedBolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
50793 if(!isWasmInitialized) {
50794 throw new Error("initializeWasm() must be awaited first!");
50796 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_absolute_expiry(this_arg);
50797 return nativeResponseValue;
50799 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_issuer(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50801 export function UnsignedBolt12Invoice_issuer(this_arg: bigint): bigint {
50802 if(!isWasmInitialized) {
50803 throw new Error("initializeWasm() must be awaited first!");
50805 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_issuer(this_arg);
50806 return nativeResponseValue;
50808 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedBolt12Invoice_message_paths(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50810 export function UnsignedBolt12Invoice_message_paths(this_arg: bigint): number {
50811 if(!isWasmInitialized) {
50812 throw new Error("initializeWasm() must be awaited first!");
50814 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_message_paths(this_arg);
50815 return nativeResponseValue;
50817 // MUST_USE_RES struct LDKCOption_QuantityZ UnsignedBolt12Invoice_supported_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50819 export function UnsignedBolt12Invoice_supported_quantity(this_arg: bigint): bigint {
50820 if(!isWasmInitialized) {
50821 throw new Error("initializeWasm() must be awaited first!");
50823 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_supported_quantity(this_arg);
50824 return nativeResponseValue;
50826 // MUST_USE_RES struct LDKu8slice UnsignedBolt12Invoice_payer_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50828 export function UnsignedBolt12Invoice_payer_metadata(this_arg: bigint): number {
50829 if(!isWasmInitialized) {
50830 throw new Error("initializeWasm() must be awaited first!");
50832 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_metadata(this_arg);
50833 return nativeResponseValue;
50835 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedBolt12Invoice_invoice_request_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50837 export function UnsignedBolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
50838 if(!isWasmInitialized) {
50839 throw new Error("initializeWasm() must be awaited first!");
50841 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_request_features(this_arg);
50842 return nativeResponseValue;
50844 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50846 export function UnsignedBolt12Invoice_quantity(this_arg: bigint): bigint {
50847 if(!isWasmInitialized) {
50848 throw new Error("initializeWasm() must be awaited first!");
50850 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_quantity(this_arg);
50851 return nativeResponseValue;
50853 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_payer_id(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50855 export function UnsignedBolt12Invoice_payer_id(this_arg: bigint): number {
50856 if(!isWasmInitialized) {
50857 throw new Error("initializeWasm() must be awaited first!");
50859 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_id(this_arg);
50860 return nativeResponseValue;
50862 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_payer_note(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50864 export function UnsignedBolt12Invoice_payer_note(this_arg: bigint): bigint {
50865 if(!isWasmInitialized) {
50866 throw new Error("initializeWasm() must be awaited first!");
50868 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_note(this_arg);
50869 return nativeResponseValue;
50871 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_created_at(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50873 export function UnsignedBolt12Invoice_created_at(this_arg: bigint): bigint {
50874 if(!isWasmInitialized) {
50875 throw new Error("initializeWasm() must be awaited first!");
50877 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_created_at(this_arg);
50878 return nativeResponseValue;
50880 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_relative_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50882 export function UnsignedBolt12Invoice_relative_expiry(this_arg: bigint): bigint {
50883 if(!isWasmInitialized) {
50884 throw new Error("initializeWasm() must be awaited first!");
50886 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_relative_expiry(this_arg);
50887 return nativeResponseValue;
50889 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_payment_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50891 export function UnsignedBolt12Invoice_payment_hash(this_arg: bigint): number {
50892 if(!isWasmInitialized) {
50893 throw new Error("initializeWasm() must be awaited first!");
50895 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payment_hash(this_arg);
50896 return nativeResponseValue;
50898 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_amount_msats(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50900 export function UnsignedBolt12Invoice_amount_msats(this_arg: bigint): bigint {
50901 if(!isWasmInitialized) {
50902 throw new Error("initializeWasm() must be awaited first!");
50904 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount_msats(this_arg);
50905 return nativeResponseValue;
50907 // MUST_USE_RES struct LDKBolt12InvoiceFeatures UnsignedBolt12Invoice_invoice_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50909 export function UnsignedBolt12Invoice_invoice_features(this_arg: bigint): bigint {
50910 if(!isWasmInitialized) {
50911 throw new Error("initializeWasm() must be awaited first!");
50913 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_features(this_arg);
50914 return nativeResponseValue;
50916 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
50918 export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
50919 if(!isWasmInitialized) {
50920 throw new Error("initializeWasm() must be awaited first!");
50922 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
50923 return nativeResponseValue;
50925 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ Bolt12Invoice_offer_chains(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50927 export function Bolt12Invoice_offer_chains(this_arg: bigint): bigint {
50928 if(!isWasmInitialized) {
50929 throw new Error("initializeWasm() must be awaited first!");
50931 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_chains(this_arg);
50932 return nativeResponseValue;
50934 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_chain(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50936 export function Bolt12Invoice_chain(this_arg: bigint): number {
50937 if(!isWasmInitialized) {
50938 throw new Error("initializeWasm() must be awaited first!");
50940 const nativeResponseValue = wasm.TS_Bolt12Invoice_chain(this_arg);
50941 return nativeResponseValue;
50943 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt12Invoice_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50945 export function Bolt12Invoice_metadata(this_arg: bigint): bigint {
50946 if(!isWasmInitialized) {
50947 throw new Error("initializeWasm() must be awaited first!");
50949 const nativeResponseValue = wasm.TS_Bolt12Invoice_metadata(this_arg);
50950 return nativeResponseValue;
50952 // MUST_USE_RES struct LDKCOption_AmountZ Bolt12Invoice_amount(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50954 export function Bolt12Invoice_amount(this_arg: bigint): bigint {
50955 if(!isWasmInitialized) {
50956 throw new Error("initializeWasm() must be awaited first!");
50958 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount(this_arg);
50959 return nativeResponseValue;
50961 // MUST_USE_RES struct LDKOfferFeatures Bolt12Invoice_offer_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50963 export function Bolt12Invoice_offer_features(this_arg: bigint): bigint {
50964 if(!isWasmInitialized) {
50965 throw new Error("initializeWasm() must be awaited first!");
50967 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_features(this_arg);
50968 return nativeResponseValue;
50970 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50972 export function Bolt12Invoice_description(this_arg: bigint): bigint {
50973 if(!isWasmInitialized) {
50974 throw new Error("initializeWasm() must be awaited first!");
50976 const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
50977 return nativeResponseValue;
50979 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_absolute_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50981 export function Bolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
50982 if(!isWasmInitialized) {
50983 throw new Error("initializeWasm() must be awaited first!");
50985 const nativeResponseValue = wasm.TS_Bolt12Invoice_absolute_expiry(this_arg);
50986 return nativeResponseValue;
50988 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_issuer(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50990 export function Bolt12Invoice_issuer(this_arg: bigint): bigint {
50991 if(!isWasmInitialized) {
50992 throw new Error("initializeWasm() must be awaited first!");
50994 const nativeResponseValue = wasm.TS_Bolt12Invoice_issuer(this_arg);
50995 return nativeResponseValue;
50997 // MUST_USE_RES struct LDKCVec_BlindedPathZ Bolt12Invoice_message_paths(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
50999 export function Bolt12Invoice_message_paths(this_arg: bigint): number {
51000 if(!isWasmInitialized) {
51001 throw new Error("initializeWasm() must be awaited first!");
51003 const nativeResponseValue = wasm.TS_Bolt12Invoice_message_paths(this_arg);
51004 return nativeResponseValue;
51006 // MUST_USE_RES struct LDKCOption_QuantityZ Bolt12Invoice_supported_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51008 export function Bolt12Invoice_supported_quantity(this_arg: bigint): bigint {
51009 if(!isWasmInitialized) {
51010 throw new Error("initializeWasm() must be awaited first!");
51012 const nativeResponseValue = wasm.TS_Bolt12Invoice_supported_quantity(this_arg);
51013 return nativeResponseValue;
51015 // MUST_USE_RES struct LDKu8slice Bolt12Invoice_payer_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51017 export function Bolt12Invoice_payer_metadata(this_arg: bigint): number {
51018 if(!isWasmInitialized) {
51019 throw new Error("initializeWasm() must be awaited first!");
51021 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_metadata(this_arg);
51022 return nativeResponseValue;
51024 // MUST_USE_RES struct LDKInvoiceRequestFeatures Bolt12Invoice_invoice_request_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51026 export function Bolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
51027 if(!isWasmInitialized) {
51028 throw new Error("initializeWasm() must be awaited first!");
51030 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_request_features(this_arg);
51031 return nativeResponseValue;
51033 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51035 export function Bolt12Invoice_quantity(this_arg: bigint): bigint {
51036 if(!isWasmInitialized) {
51037 throw new Error("initializeWasm() must be awaited first!");
51039 const nativeResponseValue = wasm.TS_Bolt12Invoice_quantity(this_arg);
51040 return nativeResponseValue;
51042 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_payer_id(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51044 export function Bolt12Invoice_payer_id(this_arg: bigint): number {
51045 if(!isWasmInitialized) {
51046 throw new Error("initializeWasm() must be awaited first!");
51048 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_id(this_arg);
51049 return nativeResponseValue;
51051 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_payer_note(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51053 export function Bolt12Invoice_payer_note(this_arg: bigint): bigint {
51054 if(!isWasmInitialized) {
51055 throw new Error("initializeWasm() must be awaited first!");
51057 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_note(this_arg);
51058 return nativeResponseValue;
51060 // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51062 export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
51063 if(!isWasmInitialized) {
51064 throw new Error("initializeWasm() must be awaited first!");
51066 const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
51067 return nativeResponseValue;
51069 // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51071 export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
51072 if(!isWasmInitialized) {
51073 throw new Error("initializeWasm() must be awaited first!");
51075 const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
51076 return nativeResponseValue;
51078 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51080 export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
51081 if(!isWasmInitialized) {
51082 throw new Error("initializeWasm() must be awaited first!");
51084 const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
51085 return nativeResponseValue;
51087 // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51089 export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
51090 if(!isWasmInitialized) {
51091 throw new Error("initializeWasm() must be awaited first!");
51093 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
51094 return nativeResponseValue;
51096 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51098 export function Bolt12Invoice_invoice_features(this_arg: bigint): bigint {
51099 if(!isWasmInitialized) {
51100 throw new Error("initializeWasm() must be awaited first!");
51102 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_features(this_arg);
51103 return nativeResponseValue;
51105 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51107 export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
51108 if(!isWasmInitialized) {
51109 throw new Error("initializeWasm() must be awaited first!");
51111 const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
51112 return nativeResponseValue;
51114 // MUST_USE_RES struct LDKSchnorrSignature Bolt12Invoice_signature(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51116 export function Bolt12Invoice_signature(this_arg: bigint): number {
51117 if(!isWasmInitialized) {
51118 throw new Error("initializeWasm() must be awaited first!");
51120 const nativeResponseValue = wasm.TS_Bolt12Invoice_signature(this_arg);
51121 return nativeResponseValue;
51123 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
51125 export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
51126 if(!isWasmInitialized) {
51127 throw new Error("initializeWasm() must be awaited first!");
51129 const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
51130 return nativeResponseValue;
51132 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
51134 export function Bolt12Invoice_verify(this_arg: bigint, key: bigint): bigint {
51135 if(!isWasmInitialized) {
51136 throw new Error("initializeWasm() must be awaited first!");
51138 const nativeResponseValue = wasm.TS_Bolt12Invoice_verify(this_arg, key);
51139 return nativeResponseValue;
51141 // uint64_t Bolt12Invoice_hash(const struct LDKBolt12Invoice *NONNULL_PTR o);
51143 export function Bolt12Invoice_hash(o: bigint): bigint {
51144 if(!isWasmInitialized) {
51145 throw new Error("initializeWasm() must be awaited first!");
51147 const nativeResponseValue = wasm.TS_Bolt12Invoice_hash(o);
51148 return nativeResponseValue;
51150 // struct LDKCVec_u8Z UnsignedBolt12Invoice_write(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR obj);
51152 export function UnsignedBolt12Invoice_write(obj: bigint): number {
51153 if(!isWasmInitialized) {
51154 throw new Error("initializeWasm() must be awaited first!");
51156 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_write(obj);
51157 return nativeResponseValue;
51159 // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
51161 export function Bolt12Invoice_write(obj: bigint): number {
51162 if(!isWasmInitialized) {
51163 throw new Error("initializeWasm() must be awaited first!");
51165 const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
51166 return nativeResponseValue;
51168 // void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
51170 export function BlindedPayInfo_free(this_obj: bigint): void {
51171 if(!isWasmInitialized) {
51172 throw new Error("initializeWasm() must be awaited first!");
51174 const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
51175 // debug statements here
51177 // uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51179 export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
51180 if(!isWasmInitialized) {
51181 throw new Error("initializeWasm() must be awaited first!");
51183 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
51184 return nativeResponseValue;
51186 // void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
51188 export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
51189 if(!isWasmInitialized) {
51190 throw new Error("initializeWasm() must be awaited first!");
51192 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
51193 // debug statements here
51195 // uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51197 export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
51198 if(!isWasmInitialized) {
51199 throw new Error("initializeWasm() must be awaited first!");
51201 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
51202 return nativeResponseValue;
51204 // void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
51206 export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
51207 if(!isWasmInitialized) {
51208 throw new Error("initializeWasm() must be awaited first!");
51210 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
51211 // debug statements here
51213 // uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51215 export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
51216 if(!isWasmInitialized) {
51217 throw new Error("initializeWasm() must be awaited first!");
51219 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
51220 return nativeResponseValue;
51222 // void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
51224 export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
51225 if(!isWasmInitialized) {
51226 throw new Error("initializeWasm() must be awaited first!");
51228 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
51229 // debug statements here
51231 // uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51233 export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
51234 if(!isWasmInitialized) {
51235 throw new Error("initializeWasm() must be awaited first!");
51237 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
51238 return nativeResponseValue;
51240 // void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
51242 export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
51243 if(!isWasmInitialized) {
51244 throw new Error("initializeWasm() must be awaited first!");
51246 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
51247 // debug statements here
51249 // uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51251 export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
51252 if(!isWasmInitialized) {
51253 throw new Error("initializeWasm() must be awaited first!");
51255 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
51256 return nativeResponseValue;
51258 // void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
51260 export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
51261 if(!isWasmInitialized) {
51262 throw new Error("initializeWasm() must be awaited first!");
51264 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
51265 // debug statements here
51267 // struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
51269 export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
51270 if(!isWasmInitialized) {
51271 throw new Error("initializeWasm() must be awaited first!");
51273 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
51274 return nativeResponseValue;
51276 // void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
51278 export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
51279 if(!isWasmInitialized) {
51280 throw new Error("initializeWasm() must be awaited first!");
51282 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
51283 // debug statements here
51285 // MUST_USE_RES struct LDKBlindedPayInfo BlindedPayInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKBlindedHopFeatures features_arg);
51287 export function BlindedPayInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, features_arg: bigint): bigint {
51288 if(!isWasmInitialized) {
51289 throw new Error("initializeWasm() must be awaited first!");
51291 const nativeResponseValue = wasm.TS_BlindedPayInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, features_arg);
51292 return nativeResponseValue;
51294 // uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
51296 export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
51297 if(!isWasmInitialized) {
51298 throw new Error("initializeWasm() must be awaited first!");
51300 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
51301 return nativeResponseValue;
51303 // struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
51305 export function BlindedPayInfo_clone(orig: bigint): bigint {
51306 if(!isWasmInitialized) {
51307 throw new Error("initializeWasm() must be awaited first!");
51309 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
51310 return nativeResponseValue;
51312 // uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
51314 export function BlindedPayInfo_hash(o: bigint): bigint {
51315 if(!isWasmInitialized) {
51316 throw new Error("initializeWasm() must be awaited first!");
51318 const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
51319 return nativeResponseValue;
51321 // bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
51323 export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
51324 if(!isWasmInitialized) {
51325 throw new Error("initializeWasm() must be awaited first!");
51327 const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
51328 return nativeResponseValue;
51330 // struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
51332 export function BlindedPayInfo_write(obj: bigint): number {
51333 if(!isWasmInitialized) {
51334 throw new Error("initializeWasm() must be awaited first!");
51336 const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
51337 return nativeResponseValue;
51339 // struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
51341 export function BlindedPayInfo_read(ser: number): bigint {
51342 if(!isWasmInitialized) {
51343 throw new Error("initializeWasm() must be awaited first!");
51345 const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
51346 return nativeResponseValue;
51348 // void InvoiceError_free(struct LDKInvoiceError this_obj);
51350 export function InvoiceError_free(this_obj: bigint): void {
51351 if(!isWasmInitialized) {
51352 throw new Error("initializeWasm() must be awaited first!");
51354 const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
51355 // debug statements here
51357 // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
51359 export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
51360 if(!isWasmInitialized) {
51361 throw new Error("initializeWasm() must be awaited first!");
51363 const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
51364 return nativeResponseValue;
51366 // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
51368 export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
51369 if(!isWasmInitialized) {
51370 throw new Error("initializeWasm() must be awaited first!");
51372 const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
51373 // debug statements here
51375 // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
51377 export function InvoiceError_get_message(this_ptr: bigint): bigint {
51378 if(!isWasmInitialized) {
51379 throw new Error("initializeWasm() must be awaited first!");
51381 const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
51382 return nativeResponseValue;
51384 // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
51386 export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
51387 if(!isWasmInitialized) {
51388 throw new Error("initializeWasm() must be awaited first!");
51390 const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
51391 // debug statements here
51393 // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
51395 export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
51396 if(!isWasmInitialized) {
51397 throw new Error("initializeWasm() must be awaited first!");
51399 const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
51400 return nativeResponseValue;
51402 // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
51404 export function InvoiceError_clone_ptr(arg: bigint): bigint {
51405 if(!isWasmInitialized) {
51406 throw new Error("initializeWasm() must be awaited first!");
51408 const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
51409 return nativeResponseValue;
51411 // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
51413 export function InvoiceError_clone(orig: bigint): bigint {
51414 if(!isWasmInitialized) {
51415 throw new Error("initializeWasm() must be awaited first!");
51417 const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
51418 return nativeResponseValue;
51420 // void ErroneousField_free(struct LDKErroneousField this_obj);
51422 export function ErroneousField_free(this_obj: bigint): void {
51423 if(!isWasmInitialized) {
51424 throw new Error("initializeWasm() must be awaited first!");
51426 const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
51427 // debug statements here
51429 // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
51431 export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
51432 if(!isWasmInitialized) {
51433 throw new Error("initializeWasm() must be awaited first!");
51435 const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
51436 return nativeResponseValue;
51438 // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
51440 export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
51441 if(!isWasmInitialized) {
51442 throw new Error("initializeWasm() must be awaited first!");
51444 const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
51445 // debug statements here
51447 // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
51449 export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
51450 if(!isWasmInitialized) {
51451 throw new Error("initializeWasm() must be awaited first!");
51453 const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
51454 return nativeResponseValue;
51456 // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
51458 export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
51459 if(!isWasmInitialized) {
51460 throw new Error("initializeWasm() must be awaited first!");
51462 const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
51463 // debug statements here
51465 // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
51467 export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
51468 if(!isWasmInitialized) {
51469 throw new Error("initializeWasm() must be awaited first!");
51471 const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
51472 return nativeResponseValue;
51474 // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
51476 export function ErroneousField_clone_ptr(arg: bigint): bigint {
51477 if(!isWasmInitialized) {
51478 throw new Error("initializeWasm() must be awaited first!");
51480 const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
51481 return nativeResponseValue;
51483 // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
51485 export function ErroneousField_clone(orig: bigint): bigint {
51486 if(!isWasmInitialized) {
51487 throw new Error("initializeWasm() must be awaited first!");
51489 const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
51490 return nativeResponseValue;
51492 // MUST_USE_RES struct LDKInvoiceError InvoiceError_from_string(struct LDKStr s);
51494 export function InvoiceError_from_string(s: number): bigint {
51495 if(!isWasmInitialized) {
51496 throw new Error("initializeWasm() must be awaited first!");
51498 const nativeResponseValue = wasm.TS_InvoiceError_from_string(s);
51499 return nativeResponseValue;
51501 // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
51503 export function InvoiceError_write(obj: bigint): number {
51504 if(!isWasmInitialized) {
51505 throw new Error("initializeWasm() must be awaited first!");
51507 const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
51508 return nativeResponseValue;
51510 // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
51512 export function InvoiceError_read(ser: number): bigint {
51513 if(!isWasmInitialized) {
51514 throw new Error("initializeWasm() must be awaited first!");
51516 const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
51517 return nativeResponseValue;
51519 // void InvoiceRequestWithExplicitPayerIdBuilder_free(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_obj);
51521 export function InvoiceRequestWithExplicitPayerIdBuilder_free(this_obj: bigint): void {
51522 if(!isWasmInitialized) {
51523 throw new Error("initializeWasm() must be awaited first!");
51525 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_free(this_obj);
51526 // debug statements here
51528 // void InvoiceRequestWithDerivedPayerIdBuilder_free(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_obj);
51530 export function InvoiceRequestWithDerivedPayerIdBuilder_free(this_obj: bigint): void {
51531 if(!isWasmInitialized) {
51532 throw new Error("initializeWasm() must be awaited first!");
51534 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_free(this_obj);
51535 // debug statements here
51537 // MUST_USE_RES struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_build(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg);
51539 export function InvoiceRequestWithExplicitPayerIdBuilder_build(this_arg: bigint): bigint {
51540 if(!isWasmInitialized) {
51541 throw new Error("initializeWasm() must be awaited first!");
51543 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_build(this_arg);
51544 return nativeResponseValue;
51546 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_chain(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, enum LDKNetwork network);
51548 export function InvoiceRequestWithExplicitPayerIdBuilder_chain(this_arg: bigint, network: Network): bigint {
51549 if(!isWasmInitialized) {
51550 throw new Error("initializeWasm() must be awaited first!");
51552 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_chain(this_arg, network);
51553 return nativeResponseValue;
51555 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, uint64_t amount_msats);
51557 export function InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): bigint {
51558 if(!isWasmInitialized) {
51559 throw new Error("initializeWasm() must be awaited first!");
51561 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(this_arg, amount_msats);
51562 return nativeResponseValue;
51564 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_quantity(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, uint64_t quantity);
51566 export function InvoiceRequestWithExplicitPayerIdBuilder_quantity(this_arg: bigint, quantity: bigint): bigint {
51567 if(!isWasmInitialized) {
51568 throw new Error("initializeWasm() must be awaited first!");
51570 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_quantity(this_arg, quantity);
51571 return nativeResponseValue;
51573 // MUST_USE_RES void InvoiceRequestWithExplicitPayerIdBuilder_payer_note(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, struct LDKStr payer_note);
51575 export function InvoiceRequestWithExplicitPayerIdBuilder_payer_note(this_arg: bigint, payer_note: number): void {
51576 if(!isWasmInitialized) {
51577 throw new Error("initializeWasm() must be awaited first!");
51579 const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_payer_note(this_arg, payer_note);
51580 // debug statements here
51582 // MUST_USE_RES struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg);
51584 export function InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(this_arg: bigint): bigint {
51585 if(!isWasmInitialized) {
51586 throw new Error("initializeWasm() must be awaited first!");
51588 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(this_arg);
51589 return nativeResponseValue;
51591 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_chain(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, enum LDKNetwork network);
51593 export function InvoiceRequestWithDerivedPayerIdBuilder_chain(this_arg: bigint, network: Network): bigint {
51594 if(!isWasmInitialized) {
51595 throw new Error("initializeWasm() must be awaited first!");
51597 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_chain(this_arg, network);
51598 return nativeResponseValue;
51600 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, uint64_t amount_msats);
51602 export function InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): bigint {
51603 if(!isWasmInitialized) {
51604 throw new Error("initializeWasm() must be awaited first!");
51606 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(this_arg, amount_msats);
51607 return nativeResponseValue;
51609 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_quantity(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, uint64_t quantity);
51611 export function InvoiceRequestWithDerivedPayerIdBuilder_quantity(this_arg: bigint, quantity: bigint): bigint {
51612 if(!isWasmInitialized) {
51613 throw new Error("initializeWasm() must be awaited first!");
51615 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_quantity(this_arg, quantity);
51616 return nativeResponseValue;
51618 // MUST_USE_RES void InvoiceRequestWithDerivedPayerIdBuilder_payer_note(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, struct LDKStr payer_note);
51620 export function InvoiceRequestWithDerivedPayerIdBuilder_payer_note(this_arg: bigint, payer_note: number): void {
51621 if(!isWasmInitialized) {
51622 throw new Error("initializeWasm() must be awaited first!");
51624 const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_payer_note(this_arg, payer_note);
51625 // debug statements here
51627 // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
51629 export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
51630 if(!isWasmInitialized) {
51631 throw new Error("initializeWasm() must be awaited first!");
51633 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
51634 // debug statements here
51636 // uint64_t UnsignedInvoiceRequest_clone_ptr(LDKUnsignedInvoiceRequest *NONNULL_PTR arg);
51638 export function UnsignedInvoiceRequest_clone_ptr(arg: bigint): bigint {
51639 if(!isWasmInitialized) {
51640 throw new Error("initializeWasm() must be awaited first!");
51642 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_clone_ptr(arg);
51643 return nativeResponseValue;
51645 // struct LDKUnsignedInvoiceRequest UnsignedInvoiceRequest_clone(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR orig);
51647 export function UnsignedInvoiceRequest_clone(orig: bigint): bigint {
51648 if(!isWasmInitialized) {
51649 throw new Error("initializeWasm() must be awaited first!");
51651 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_clone(orig);
51652 return nativeResponseValue;
51654 // void SignInvoiceRequestFn_free(struct LDKSignInvoiceRequestFn this_ptr);
51656 export function SignInvoiceRequestFn_free(this_ptr: bigint): void {
51657 if(!isWasmInitialized) {
51658 throw new Error("initializeWasm() must be awaited first!");
51660 const nativeResponseValue = wasm.TS_SignInvoiceRequestFn_free(this_ptr);
51661 // debug statements here
51663 // MUST_USE_RES struct LDKTaggedHash UnsignedInvoiceRequest_tagged_hash(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51665 export function UnsignedInvoiceRequest_tagged_hash(this_arg: bigint): bigint {
51666 if(!isWasmInitialized) {
51667 throw new Error("initializeWasm() must be awaited first!");
51669 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_tagged_hash(this_arg);
51670 return nativeResponseValue;
51672 // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
51674 export function InvoiceRequest_free(this_obj: bigint): void {
51675 if(!isWasmInitialized) {
51676 throw new Error("initializeWasm() must be awaited first!");
51678 const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
51679 // debug statements here
51681 // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
51683 export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
51684 if(!isWasmInitialized) {
51685 throw new Error("initializeWasm() must be awaited first!");
51687 const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
51688 return nativeResponseValue;
51690 // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
51692 export function InvoiceRequest_clone(orig: bigint): bigint {
51693 if(!isWasmInitialized) {
51694 throw new Error("initializeWasm() must be awaited first!");
51696 const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
51697 return nativeResponseValue;
51699 // void VerifiedInvoiceRequest_free(struct LDKVerifiedInvoiceRequest this_obj);
51701 export function VerifiedInvoiceRequest_free(this_obj: bigint): void {
51702 if(!isWasmInitialized) {
51703 throw new Error("initializeWasm() must be awaited first!");
51705 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_free(this_obj);
51706 // debug statements here
51708 // struct LDKOfferId VerifiedInvoiceRequest_get_offer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
51710 export function VerifiedInvoiceRequest_get_offer_id(this_ptr: bigint): bigint {
51711 if(!isWasmInitialized) {
51712 throw new Error("initializeWasm() must be awaited first!");
51714 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_offer_id(this_ptr);
51715 return nativeResponseValue;
51717 // void VerifiedInvoiceRequest_set_offer_id(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKOfferId val);
51719 export function VerifiedInvoiceRequest_set_offer_id(this_ptr: bigint, val: bigint): void {
51720 if(!isWasmInitialized) {
51721 throw new Error("initializeWasm() must be awaited first!");
51723 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_offer_id(this_ptr, val);
51724 // debug statements here
51726 // struct LDKCOption_SecretKeyZ VerifiedInvoiceRequest_get_keys(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
51728 export function VerifiedInvoiceRequest_get_keys(this_ptr: bigint): bigint {
51729 if(!isWasmInitialized) {
51730 throw new Error("initializeWasm() must be awaited first!");
51732 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_keys(this_ptr);
51733 return nativeResponseValue;
51735 // void VerifiedInvoiceRequest_set_keys(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKCOption_SecretKeyZ val);
51737 export function VerifiedInvoiceRequest_set_keys(this_ptr: bigint, val: bigint): void {
51738 if(!isWasmInitialized) {
51739 throw new Error("initializeWasm() must be awaited first!");
51741 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_keys(this_ptr, val);
51742 // debug statements here
51744 // uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg);
51746 export function VerifiedInvoiceRequest_clone_ptr(arg: bigint): bigint {
51747 if(!isWasmInitialized) {
51748 throw new Error("initializeWasm() must be awaited first!");
51750 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone_ptr(arg);
51751 return nativeResponseValue;
51753 // struct LDKVerifiedInvoiceRequest VerifiedInvoiceRequest_clone(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR orig);
51755 export function VerifiedInvoiceRequest_clone(orig: bigint): bigint {
51756 if(!isWasmInitialized) {
51757 throw new Error("initializeWasm() must be awaited first!");
51759 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone(orig);
51760 return nativeResponseValue;
51762 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ UnsignedInvoiceRequest_chains(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51764 export function UnsignedInvoiceRequest_chains(this_arg: bigint): number {
51765 if(!isWasmInitialized) {
51766 throw new Error("initializeWasm() must be awaited first!");
51768 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chains(this_arg);
51769 return nativeResponseValue;
51771 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedInvoiceRequest_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51773 export function UnsignedInvoiceRequest_metadata(this_arg: bigint): bigint {
51774 if(!isWasmInitialized) {
51775 throw new Error("initializeWasm() must be awaited first!");
51777 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_metadata(this_arg);
51778 return nativeResponseValue;
51780 // MUST_USE_RES struct LDKCOption_AmountZ UnsignedInvoiceRequest_amount(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51782 export function UnsignedInvoiceRequest_amount(this_arg: bigint): bigint {
51783 if(!isWasmInitialized) {
51784 throw new Error("initializeWasm() must be awaited first!");
51786 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount(this_arg);
51787 return nativeResponseValue;
51789 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_description(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51791 export function UnsignedInvoiceRequest_description(this_arg: bigint): bigint {
51792 if(!isWasmInitialized) {
51793 throw new Error("initializeWasm() must be awaited first!");
51795 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_description(this_arg);
51796 return nativeResponseValue;
51798 // MUST_USE_RES struct LDKOfferFeatures UnsignedInvoiceRequest_offer_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51800 export function UnsignedInvoiceRequest_offer_features(this_arg: bigint): bigint {
51801 if(!isWasmInitialized) {
51802 throw new Error("initializeWasm() must be awaited first!");
51804 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_offer_features(this_arg);
51805 return nativeResponseValue;
51807 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_absolute_expiry(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51809 export function UnsignedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
51810 if(!isWasmInitialized) {
51811 throw new Error("initializeWasm() must be awaited first!");
51813 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_absolute_expiry(this_arg);
51814 return nativeResponseValue;
51816 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_issuer(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51818 export function UnsignedInvoiceRequest_issuer(this_arg: bigint): bigint {
51819 if(!isWasmInitialized) {
51820 throw new Error("initializeWasm() must be awaited first!");
51822 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_issuer(this_arg);
51823 return nativeResponseValue;
51825 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedInvoiceRequest_paths(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51827 export function UnsignedInvoiceRequest_paths(this_arg: bigint): number {
51828 if(!isWasmInitialized) {
51829 throw new Error("initializeWasm() must be awaited first!");
51831 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_paths(this_arg);
51832 return nativeResponseValue;
51834 // MUST_USE_RES struct LDKQuantity UnsignedInvoiceRequest_supported_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51836 export function UnsignedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
51837 if(!isWasmInitialized) {
51838 throw new Error("initializeWasm() must be awaited first!");
51840 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_supported_quantity(this_arg);
51841 return nativeResponseValue;
51843 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_signing_pubkey(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51845 export function UnsignedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
51846 if(!isWasmInitialized) {
51847 throw new Error("initializeWasm() must be awaited first!");
51849 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_signing_pubkey(this_arg);
51850 return nativeResponseValue;
51852 // MUST_USE_RES struct LDKu8slice UnsignedInvoiceRequest_payer_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51854 export function UnsignedInvoiceRequest_payer_metadata(this_arg: bigint): number {
51855 if(!isWasmInitialized) {
51856 throw new Error("initializeWasm() must be awaited first!");
51858 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_metadata(this_arg);
51859 return nativeResponseValue;
51861 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedInvoiceRequest_chain(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51863 export function UnsignedInvoiceRequest_chain(this_arg: bigint): number {
51864 if(!isWasmInitialized) {
51865 throw new Error("initializeWasm() must be awaited first!");
51867 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chain(this_arg);
51868 return nativeResponseValue;
51870 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_amount_msats(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51872 export function UnsignedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
51873 if(!isWasmInitialized) {
51874 throw new Error("initializeWasm() must be awaited first!");
51876 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount_msats(this_arg);
51877 return nativeResponseValue;
51879 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedInvoiceRequest_invoice_request_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51881 export function UnsignedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
51882 if(!isWasmInitialized) {
51883 throw new Error("initializeWasm() must be awaited first!");
51885 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_invoice_request_features(this_arg);
51886 return nativeResponseValue;
51888 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51890 export function UnsignedInvoiceRequest_quantity(this_arg: bigint): bigint {
51891 if(!isWasmInitialized) {
51892 throw new Error("initializeWasm() must be awaited first!");
51894 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_quantity(this_arg);
51895 return nativeResponseValue;
51897 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_payer_id(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51899 export function UnsignedInvoiceRequest_payer_id(this_arg: bigint): number {
51900 if(!isWasmInitialized) {
51901 throw new Error("initializeWasm() must be awaited first!");
51903 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_id(this_arg);
51904 return nativeResponseValue;
51906 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_payer_note(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
51908 export function UnsignedInvoiceRequest_payer_note(this_arg: bigint): bigint {
51909 if(!isWasmInitialized) {
51910 throw new Error("initializeWasm() must be awaited first!");
51912 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_note(this_arg);
51913 return nativeResponseValue;
51915 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ InvoiceRequest_chains(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51917 export function InvoiceRequest_chains(this_arg: bigint): number {
51918 if(!isWasmInitialized) {
51919 throw new Error("initializeWasm() must be awaited first!");
51921 const nativeResponseValue = wasm.TS_InvoiceRequest_chains(this_arg);
51922 return nativeResponseValue;
51924 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51926 export function InvoiceRequest_metadata(this_arg: bigint): bigint {
51927 if(!isWasmInitialized) {
51928 throw new Error("initializeWasm() must be awaited first!");
51930 const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
51931 return nativeResponseValue;
51933 // MUST_USE_RES struct LDKCOption_AmountZ InvoiceRequest_amount(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51935 export function InvoiceRequest_amount(this_arg: bigint): bigint {
51936 if(!isWasmInitialized) {
51937 throw new Error("initializeWasm() must be awaited first!");
51939 const nativeResponseValue = wasm.TS_InvoiceRequest_amount(this_arg);
51940 return nativeResponseValue;
51942 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_description(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51944 export function InvoiceRequest_description(this_arg: bigint): bigint {
51945 if(!isWasmInitialized) {
51946 throw new Error("initializeWasm() must be awaited first!");
51948 const nativeResponseValue = wasm.TS_InvoiceRequest_description(this_arg);
51949 return nativeResponseValue;
51951 // MUST_USE_RES struct LDKOfferFeatures InvoiceRequest_offer_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51953 export function InvoiceRequest_offer_features(this_arg: bigint): bigint {
51954 if(!isWasmInitialized) {
51955 throw new Error("initializeWasm() must be awaited first!");
51957 const nativeResponseValue = wasm.TS_InvoiceRequest_offer_features(this_arg);
51958 return nativeResponseValue;
51960 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_absolute_expiry(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51962 export function InvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
51963 if(!isWasmInitialized) {
51964 throw new Error("initializeWasm() must be awaited first!");
51966 const nativeResponseValue = wasm.TS_InvoiceRequest_absolute_expiry(this_arg);
51967 return nativeResponseValue;
51969 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_issuer(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51971 export function InvoiceRequest_issuer(this_arg: bigint): bigint {
51972 if(!isWasmInitialized) {
51973 throw new Error("initializeWasm() must be awaited first!");
51975 const nativeResponseValue = wasm.TS_InvoiceRequest_issuer(this_arg);
51976 return nativeResponseValue;
51978 // MUST_USE_RES struct LDKCVec_BlindedPathZ InvoiceRequest_paths(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51980 export function InvoiceRequest_paths(this_arg: bigint): number {
51981 if(!isWasmInitialized) {
51982 throw new Error("initializeWasm() must be awaited first!");
51984 const nativeResponseValue = wasm.TS_InvoiceRequest_paths(this_arg);
51985 return nativeResponseValue;
51987 // MUST_USE_RES struct LDKQuantity InvoiceRequest_supported_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51989 export function InvoiceRequest_supported_quantity(this_arg: bigint): bigint {
51990 if(!isWasmInitialized) {
51991 throw new Error("initializeWasm() must be awaited first!");
51993 const nativeResponseValue = wasm.TS_InvoiceRequest_supported_quantity(this_arg);
51994 return nativeResponseValue;
51996 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_signing_pubkey(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
51998 export function InvoiceRequest_signing_pubkey(this_arg: bigint): number {
51999 if(!isWasmInitialized) {
52000 throw new Error("initializeWasm() must be awaited first!");
52002 const nativeResponseValue = wasm.TS_InvoiceRequest_signing_pubkey(this_arg);
52003 return nativeResponseValue;
52005 // MUST_USE_RES struct LDKu8slice InvoiceRequest_payer_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52007 export function InvoiceRequest_payer_metadata(this_arg: bigint): number {
52008 if(!isWasmInitialized) {
52009 throw new Error("initializeWasm() must be awaited first!");
52011 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_metadata(this_arg);
52012 return nativeResponseValue;
52014 // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52016 export function InvoiceRequest_chain(this_arg: bigint): number {
52017 if(!isWasmInitialized) {
52018 throw new Error("initializeWasm() must be awaited first!");
52020 const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
52021 return nativeResponseValue;
52023 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52025 export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
52026 if(!isWasmInitialized) {
52027 throw new Error("initializeWasm() must be awaited first!");
52029 const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
52030 return nativeResponseValue;
52032 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_invoice_request_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52034 export function InvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
52035 if(!isWasmInitialized) {
52036 throw new Error("initializeWasm() must be awaited first!");
52038 const nativeResponseValue = wasm.TS_InvoiceRequest_invoice_request_features(this_arg);
52039 return nativeResponseValue;
52041 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52043 export function InvoiceRequest_quantity(this_arg: bigint): bigint {
52044 if(!isWasmInitialized) {
52045 throw new Error("initializeWasm() must be awaited first!");
52047 const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
52048 return nativeResponseValue;
52050 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52052 export function InvoiceRequest_payer_id(this_arg: bigint): number {
52053 if(!isWasmInitialized) {
52054 throw new Error("initializeWasm() must be awaited first!");
52056 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
52057 return nativeResponseValue;
52059 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52061 export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
52062 if(!isWasmInitialized) {
52063 throw new Error("initializeWasm() must be awaited first!");
52065 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
52066 return nativeResponseValue;
52068 // MUST_USE_RES struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ InvoiceRequest_respond_with_no_std(const struct LDKInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
52070 export function InvoiceRequest_respond_with_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
52071 if(!isWasmInitialized) {
52072 throw new Error("initializeWasm() must be awaited first!");
52074 const nativeResponseValue = wasm.TS_InvoiceRequest_respond_with_no_std(this_arg, payment_paths, payment_hash, created_at);
52075 return nativeResponseValue;
52077 // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify(struct LDKInvoiceRequest this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
52079 export function InvoiceRequest_verify(this_arg: bigint, key: bigint): bigint {
52080 if(!isWasmInitialized) {
52081 throw new Error("initializeWasm() must be awaited first!");
52083 const nativeResponseValue = wasm.TS_InvoiceRequest_verify(this_arg, key);
52084 return nativeResponseValue;
52086 // MUST_USE_RES struct LDKSchnorrSignature InvoiceRequest_signature(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
52088 export function InvoiceRequest_signature(this_arg: bigint): number {
52089 if(!isWasmInitialized) {
52090 throw new Error("initializeWasm() must be awaited first!");
52092 const nativeResponseValue = wasm.TS_InvoiceRequest_signature(this_arg);
52093 return nativeResponseValue;
52095 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ VerifiedInvoiceRequest_chains(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52097 export function VerifiedInvoiceRequest_chains(this_arg: bigint): number {
52098 if(!isWasmInitialized) {
52099 throw new Error("initializeWasm() must be awaited first!");
52101 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chains(this_arg);
52102 return nativeResponseValue;
52104 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ VerifiedInvoiceRequest_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52106 export function VerifiedInvoiceRequest_metadata(this_arg: bigint): bigint {
52107 if(!isWasmInitialized) {
52108 throw new Error("initializeWasm() must be awaited first!");
52110 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_metadata(this_arg);
52111 return nativeResponseValue;
52113 // MUST_USE_RES struct LDKCOption_AmountZ VerifiedInvoiceRequest_amount(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52115 export function VerifiedInvoiceRequest_amount(this_arg: bigint): bigint {
52116 if(!isWasmInitialized) {
52117 throw new Error("initializeWasm() must be awaited first!");
52119 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount(this_arg);
52120 return nativeResponseValue;
52122 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_description(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52124 export function VerifiedInvoiceRequest_description(this_arg: bigint): bigint {
52125 if(!isWasmInitialized) {
52126 throw new Error("initializeWasm() must be awaited first!");
52128 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_description(this_arg);
52129 return nativeResponseValue;
52131 // MUST_USE_RES struct LDKOfferFeatures VerifiedInvoiceRequest_offer_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52133 export function VerifiedInvoiceRequest_offer_features(this_arg: bigint): bigint {
52134 if(!isWasmInitialized) {
52135 throw new Error("initializeWasm() must be awaited first!");
52137 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_offer_features(this_arg);
52138 return nativeResponseValue;
52140 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_absolute_expiry(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52142 export function VerifiedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
52143 if(!isWasmInitialized) {
52144 throw new Error("initializeWasm() must be awaited first!");
52146 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_absolute_expiry(this_arg);
52147 return nativeResponseValue;
52149 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_issuer(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52151 export function VerifiedInvoiceRequest_issuer(this_arg: bigint): bigint {
52152 if(!isWasmInitialized) {
52153 throw new Error("initializeWasm() must be awaited first!");
52155 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_issuer(this_arg);
52156 return nativeResponseValue;
52158 // MUST_USE_RES struct LDKCVec_BlindedPathZ VerifiedInvoiceRequest_paths(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52160 export function VerifiedInvoiceRequest_paths(this_arg: bigint): number {
52161 if(!isWasmInitialized) {
52162 throw new Error("initializeWasm() must be awaited first!");
52164 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_paths(this_arg);
52165 return nativeResponseValue;
52167 // MUST_USE_RES struct LDKQuantity VerifiedInvoiceRequest_supported_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52169 export function VerifiedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
52170 if(!isWasmInitialized) {
52171 throw new Error("initializeWasm() must be awaited first!");
52173 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_supported_quantity(this_arg);
52174 return nativeResponseValue;
52176 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_signing_pubkey(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52178 export function VerifiedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
52179 if(!isWasmInitialized) {
52180 throw new Error("initializeWasm() must be awaited first!");
52182 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_signing_pubkey(this_arg);
52183 return nativeResponseValue;
52185 // MUST_USE_RES struct LDKu8slice VerifiedInvoiceRequest_payer_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52187 export function VerifiedInvoiceRequest_payer_metadata(this_arg: bigint): number {
52188 if(!isWasmInitialized) {
52189 throw new Error("initializeWasm() must be awaited first!");
52191 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_metadata(this_arg);
52192 return nativeResponseValue;
52194 // MUST_USE_RES struct LDKThirtyTwoBytes VerifiedInvoiceRequest_chain(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52196 export function VerifiedInvoiceRequest_chain(this_arg: bigint): number {
52197 if(!isWasmInitialized) {
52198 throw new Error("initializeWasm() must be awaited first!");
52200 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chain(this_arg);
52201 return nativeResponseValue;
52203 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_amount_msats(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52205 export function VerifiedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
52206 if(!isWasmInitialized) {
52207 throw new Error("initializeWasm() must be awaited first!");
52209 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount_msats(this_arg);
52210 return nativeResponseValue;
52212 // MUST_USE_RES struct LDKInvoiceRequestFeatures VerifiedInvoiceRequest_invoice_request_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52214 export function VerifiedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
52215 if(!isWasmInitialized) {
52216 throw new Error("initializeWasm() must be awaited first!");
52218 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_invoice_request_features(this_arg);
52219 return nativeResponseValue;
52221 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52223 export function VerifiedInvoiceRequest_quantity(this_arg: bigint): bigint {
52224 if(!isWasmInitialized) {
52225 throw new Error("initializeWasm() must be awaited first!");
52227 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_quantity(this_arg);
52228 return nativeResponseValue;
52230 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_payer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52232 export function VerifiedInvoiceRequest_payer_id(this_arg: bigint): number {
52233 if(!isWasmInitialized) {
52234 throw new Error("initializeWasm() must be awaited first!");
52236 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_id(this_arg);
52237 return nativeResponseValue;
52239 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_payer_note(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
52241 export function VerifiedInvoiceRequest_payer_note(this_arg: bigint): bigint {
52242 if(!isWasmInitialized) {
52243 throw new Error("initializeWasm() must be awaited first!");
52245 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_note(this_arg);
52246 return nativeResponseValue;
52248 // MUST_USE_RES struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ VerifiedInvoiceRequest_respond_with_no_std(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
52250 export function VerifiedInvoiceRequest_respond_with_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
52251 if(!isWasmInitialized) {
52252 throw new Error("initializeWasm() must be awaited first!");
52254 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_respond_with_no_std(this_arg, payment_paths, payment_hash, created_at);
52255 return nativeResponseValue;
52257 // MUST_USE_RES struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ VerifiedInvoiceRequest_respond_using_derived_keys_no_std(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
52259 export function VerifiedInvoiceRequest_respond_using_derived_keys_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
52260 if(!isWasmInitialized) {
52261 throw new Error("initializeWasm() must be awaited first!");
52263 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_respond_using_derived_keys_no_std(this_arg, payment_paths, payment_hash, created_at);
52264 return nativeResponseValue;
52266 // struct LDKCVec_u8Z UnsignedInvoiceRequest_write(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR obj);
52268 export function UnsignedInvoiceRequest_write(obj: bigint): number {
52269 if(!isWasmInitialized) {
52270 throw new Error("initializeWasm() must be awaited first!");
52272 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_write(obj);
52273 return nativeResponseValue;
52275 // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
52277 export function InvoiceRequest_write(obj: bigint): number {
52278 if(!isWasmInitialized) {
52279 throw new Error("initializeWasm() must be awaited first!");
52281 const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
52282 return nativeResponseValue;
52284 // void InvoiceRequestFields_free(struct LDKInvoiceRequestFields this_obj);
52286 export function InvoiceRequestFields_free(this_obj: bigint): void {
52287 if(!isWasmInitialized) {
52288 throw new Error("initializeWasm() must be awaited first!");
52290 const nativeResponseValue = wasm.TS_InvoiceRequestFields_free(this_obj);
52291 // debug statements here
52293 // struct LDKPublicKey InvoiceRequestFields_get_payer_id(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
52295 export function InvoiceRequestFields_get_payer_id(this_ptr: bigint): number {
52296 if(!isWasmInitialized) {
52297 throw new Error("initializeWasm() must be awaited first!");
52299 const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_payer_id(this_ptr);
52300 return nativeResponseValue;
52302 // void InvoiceRequestFields_set_payer_id(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
52304 export function InvoiceRequestFields_set_payer_id(this_ptr: bigint, val: number): void {
52305 if(!isWasmInitialized) {
52306 throw new Error("initializeWasm() must be awaited first!");
52308 const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_payer_id(this_ptr, val);
52309 // debug statements here
52311 // struct LDKCOption_u64Z InvoiceRequestFields_get_quantity(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
52313 export function InvoiceRequestFields_get_quantity(this_ptr: bigint): bigint {
52314 if(!isWasmInitialized) {
52315 throw new Error("initializeWasm() must be awaited first!");
52317 const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_quantity(this_ptr);
52318 return nativeResponseValue;
52320 // void InvoiceRequestFields_set_quantity(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
52322 export function InvoiceRequestFields_set_quantity(this_ptr: bigint, val: bigint): void {
52323 if(!isWasmInitialized) {
52324 throw new Error("initializeWasm() must be awaited first!");
52326 const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_quantity(this_ptr, val);
52327 // debug statements here
52329 // struct LDKUntrustedString InvoiceRequestFields_get_payer_note_truncated(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
52331 export function InvoiceRequestFields_get_payer_note_truncated(this_ptr: bigint): bigint {
52332 if(!isWasmInitialized) {
52333 throw new Error("initializeWasm() must be awaited first!");
52335 const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_payer_note_truncated(this_ptr);
52336 return nativeResponseValue;
52338 // void InvoiceRequestFields_set_payer_note_truncated(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
52340 export function InvoiceRequestFields_set_payer_note_truncated(this_ptr: bigint, val: bigint): void {
52341 if(!isWasmInitialized) {
52342 throw new Error("initializeWasm() must be awaited first!");
52344 const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_payer_note_truncated(this_ptr, val);
52345 // debug statements here
52347 // MUST_USE_RES struct LDKInvoiceRequestFields InvoiceRequestFields_new(struct LDKPublicKey payer_id_arg, struct LDKCOption_u64Z quantity_arg, struct LDKUntrustedString payer_note_truncated_arg);
52349 export function InvoiceRequestFields_new(payer_id_arg: number, quantity_arg: bigint, payer_note_truncated_arg: bigint): bigint {
52350 if(!isWasmInitialized) {
52351 throw new Error("initializeWasm() must be awaited first!");
52353 const nativeResponseValue = wasm.TS_InvoiceRequestFields_new(payer_id_arg, quantity_arg, payer_note_truncated_arg);
52354 return nativeResponseValue;
52356 // uint64_t InvoiceRequestFields_clone_ptr(LDKInvoiceRequestFields *NONNULL_PTR arg);
52358 export function InvoiceRequestFields_clone_ptr(arg: bigint): bigint {
52359 if(!isWasmInitialized) {
52360 throw new Error("initializeWasm() must be awaited first!");
52362 const nativeResponseValue = wasm.TS_InvoiceRequestFields_clone_ptr(arg);
52363 return nativeResponseValue;
52365 // struct LDKInvoiceRequestFields InvoiceRequestFields_clone(const struct LDKInvoiceRequestFields *NONNULL_PTR orig);
52367 export function InvoiceRequestFields_clone(orig: bigint): bigint {
52368 if(!isWasmInitialized) {
52369 throw new Error("initializeWasm() must be awaited first!");
52371 const nativeResponseValue = wasm.TS_InvoiceRequestFields_clone(orig);
52372 return nativeResponseValue;
52374 // bool InvoiceRequestFields_eq(const struct LDKInvoiceRequestFields *NONNULL_PTR a, const struct LDKInvoiceRequestFields *NONNULL_PTR b);
52376 export function InvoiceRequestFields_eq(a: bigint, b: bigint): boolean {
52377 if(!isWasmInitialized) {
52378 throw new Error("initializeWasm() must be awaited first!");
52380 const nativeResponseValue = wasm.TS_InvoiceRequestFields_eq(a, b);
52381 return nativeResponseValue;
52383 // struct LDKCVec_u8Z InvoiceRequestFields_write(const struct LDKInvoiceRequestFields *NONNULL_PTR obj);
52385 export function InvoiceRequestFields_write(obj: bigint): number {
52386 if(!isWasmInitialized) {
52387 throw new Error("initializeWasm() must be awaited first!");
52389 const nativeResponseValue = wasm.TS_InvoiceRequestFields_write(obj);
52390 return nativeResponseValue;
52392 // struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ InvoiceRequestFields_read(struct LDKu8slice ser);
52394 export function InvoiceRequestFields_read(ser: number): bigint {
52395 if(!isWasmInitialized) {
52396 throw new Error("initializeWasm() must be awaited first!");
52398 const nativeResponseValue = wasm.TS_InvoiceRequestFields_read(ser);
52399 return nativeResponseValue;
52401 // void TaggedHash_free(struct LDKTaggedHash this_obj);
52403 export function TaggedHash_free(this_obj: bigint): void {
52404 if(!isWasmInitialized) {
52405 throw new Error("initializeWasm() must be awaited first!");
52407 const nativeResponseValue = wasm.TS_TaggedHash_free(this_obj);
52408 // debug statements here
52410 // uint64_t TaggedHash_clone_ptr(LDKTaggedHash *NONNULL_PTR arg);
52412 export function TaggedHash_clone_ptr(arg: bigint): bigint {
52413 if(!isWasmInitialized) {
52414 throw new Error("initializeWasm() must be awaited first!");
52416 const nativeResponseValue = wasm.TS_TaggedHash_clone_ptr(arg);
52417 return nativeResponseValue;
52419 // struct LDKTaggedHash TaggedHash_clone(const struct LDKTaggedHash *NONNULL_PTR orig);
52421 export function TaggedHash_clone(orig: bigint): bigint {
52422 if(!isWasmInitialized) {
52423 throw new Error("initializeWasm() must be awaited first!");
52425 const nativeResponseValue = wasm.TS_TaggedHash_clone(orig);
52426 return nativeResponseValue;
52428 // MUST_USE_RES const uint8_t (*TaggedHash_as_digest(const struct LDKTaggedHash *NONNULL_PTR this_arg))[32];
52430 export function TaggedHash_as_digest(this_arg: bigint): number {
52431 if(!isWasmInitialized) {
52432 throw new Error("initializeWasm() must be awaited first!");
52434 const nativeResponseValue = wasm.TS_TaggedHash_as_digest(this_arg);
52435 return nativeResponseValue;
52437 // MUST_USE_RES struct LDKStr TaggedHash_tag(const struct LDKTaggedHash *NONNULL_PTR this_arg);
52439 export function TaggedHash_tag(this_arg: bigint): number {
52440 if(!isWasmInitialized) {
52441 throw new Error("initializeWasm() must be awaited first!");
52443 const nativeResponseValue = wasm.TS_TaggedHash_tag(this_arg);
52444 return nativeResponseValue;
52446 // MUST_USE_RES struct LDKThirtyTwoBytes TaggedHash_merkle_root(const struct LDKTaggedHash *NONNULL_PTR this_arg);
52448 export function TaggedHash_merkle_root(this_arg: bigint): number {
52449 if(!isWasmInitialized) {
52450 throw new Error("initializeWasm() must be awaited first!");
52452 const nativeResponseValue = wasm.TS_TaggedHash_merkle_root(this_arg);
52453 return nativeResponseValue;
52455 // void SignError_free(struct LDKSignError this_ptr);
52457 export function SignError_free(this_ptr: bigint): void {
52458 if(!isWasmInitialized) {
52459 throw new Error("initializeWasm() must be awaited first!");
52461 const nativeResponseValue = wasm.TS_SignError_free(this_ptr);
52462 // debug statements here
52464 // uint64_t SignError_clone_ptr(LDKSignError *NONNULL_PTR arg);
52466 export function SignError_clone_ptr(arg: bigint): bigint {
52467 if(!isWasmInitialized) {
52468 throw new Error("initializeWasm() must be awaited first!");
52470 const nativeResponseValue = wasm.TS_SignError_clone_ptr(arg);
52471 return nativeResponseValue;
52473 // struct LDKSignError SignError_clone(const struct LDKSignError *NONNULL_PTR orig);
52475 export function SignError_clone(orig: bigint): bigint {
52476 if(!isWasmInitialized) {
52477 throw new Error("initializeWasm() must be awaited first!");
52479 const nativeResponseValue = wasm.TS_SignError_clone(orig);
52480 return nativeResponseValue;
52482 // struct LDKSignError SignError_signing(void);
52484 export function SignError_signing(): bigint {
52485 if(!isWasmInitialized) {
52486 throw new Error("initializeWasm() must be awaited first!");
52488 const nativeResponseValue = wasm.TS_SignError_signing();
52489 return nativeResponseValue;
52491 // struct LDKSignError SignError_verification(enum LDKSecp256k1Error a);
52493 export function SignError_verification(a: Secp256k1Error): bigint {
52494 if(!isWasmInitialized) {
52495 throw new Error("initializeWasm() must be awaited first!");
52497 const nativeResponseValue = wasm.TS_SignError_verification(a);
52498 return nativeResponseValue;
52500 // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
52502 export function Bolt12ParseError_free(this_obj: bigint): void {
52503 if(!isWasmInitialized) {
52504 throw new Error("initializeWasm() must be awaited first!");
52506 const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
52507 // debug statements here
52509 // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
52511 export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
52512 if(!isWasmInitialized) {
52513 throw new Error("initializeWasm() must be awaited first!");
52515 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
52516 return nativeResponseValue;
52518 // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
52520 export function Bolt12ParseError_clone(orig: bigint): bigint {
52521 if(!isWasmInitialized) {
52522 throw new Error("initializeWasm() must be awaited first!");
52524 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
52525 return nativeResponseValue;
52527 // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
52529 export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
52530 if(!isWasmInitialized) {
52531 throw new Error("initializeWasm() must be awaited first!");
52533 const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
52534 return nativeResponseValue;
52536 // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
52538 export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
52539 if(!isWasmInitialized) {
52540 throw new Error("initializeWasm() must be awaited first!");
52542 const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
52543 return nativeResponseValue;
52545 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
52547 export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
52548 if(!isWasmInitialized) {
52549 throw new Error("initializeWasm() must be awaited first!");
52551 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
52552 return nativeResponseValue;
52554 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
52556 export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
52557 if(!isWasmInitialized) {
52558 throw new Error("initializeWasm() must be awaited first!");
52560 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
52561 return nativeResponseValue;
52563 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
52565 export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
52566 if(!isWasmInitialized) {
52567 throw new Error("initializeWasm() must be awaited first!");
52569 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
52570 return nativeResponseValue;
52572 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
52574 export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
52575 if(!isWasmInitialized) {
52576 throw new Error("initializeWasm() must be awaited first!");
52578 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
52579 return nativeResponseValue;
52581 // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
52583 export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
52584 if(!isWasmInitialized) {
52585 throw new Error("initializeWasm() must be awaited first!");
52587 const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
52588 return nativeResponseValue;
52590 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
52592 export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
52593 if(!isWasmInitialized) {
52594 throw new Error("initializeWasm() must be awaited first!");
52596 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
52597 return nativeResponseValue;
52599 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
52601 export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
52602 if(!isWasmInitialized) {
52603 throw new Error("initializeWasm() must be awaited first!");
52605 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
52606 return nativeResponseValue;
52608 // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
52610 export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
52611 if(!isWasmInitialized) {
52612 throw new Error("initializeWasm() must be awaited first!");
52614 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
52615 return nativeResponseValue;
52617 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
52619 export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
52620 if(!isWasmInitialized) {
52621 throw new Error("initializeWasm() must be awaited first!");
52623 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
52624 return nativeResponseValue;
52626 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
52628 export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
52629 if(!isWasmInitialized) {
52630 throw new Error("initializeWasm() must be awaited first!");
52632 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
52633 return nativeResponseValue;
52635 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
52637 export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
52638 if(!isWasmInitialized) {
52639 throw new Error("initializeWasm() must be awaited first!");
52641 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
52642 return nativeResponseValue;
52644 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
52646 export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
52647 if(!isWasmInitialized) {
52648 throw new Error("initializeWasm() must be awaited first!");
52650 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
52651 return nativeResponseValue;
52653 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
52655 export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
52656 if(!isWasmInitialized) {
52657 throw new Error("initializeWasm() must be awaited first!");
52659 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
52660 return nativeResponseValue;
52662 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
52664 export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
52665 if(!isWasmInitialized) {
52666 throw new Error("initializeWasm() must be awaited first!");
52668 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
52669 return nativeResponseValue;
52671 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
52673 export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
52674 if(!isWasmInitialized) {
52675 throw new Error("initializeWasm() must be awaited first!");
52677 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
52678 return nativeResponseValue;
52680 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
52682 export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
52683 if(!isWasmInitialized) {
52684 throw new Error("initializeWasm() must be awaited first!");
52686 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
52687 return nativeResponseValue;
52689 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
52691 export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
52692 if(!isWasmInitialized) {
52693 throw new Error("initializeWasm() must be awaited first!");
52695 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
52696 return nativeResponseValue;
52698 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
52700 export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
52701 if(!isWasmInitialized) {
52702 throw new Error("initializeWasm() must be awaited first!");
52704 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
52705 return nativeResponseValue;
52707 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
52709 export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
52710 if(!isWasmInitialized) {
52711 throw new Error("initializeWasm() must be awaited first!");
52713 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
52714 return nativeResponseValue;
52716 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
52718 export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
52719 if(!isWasmInitialized) {
52720 throw new Error("initializeWasm() must be awaited first!");
52722 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
52723 return nativeResponseValue;
52725 // enum LDKBolt12SemanticError Bolt12SemanticError_duplicate_payment_id(void);
52727 export function Bolt12SemanticError_duplicate_payment_id(): Bolt12SemanticError {
52728 if(!isWasmInitialized) {
52729 throw new Error("initializeWasm() must be awaited first!");
52731 const nativeResponseValue = wasm.TS_Bolt12SemanticError_duplicate_payment_id();
52732 return nativeResponseValue;
52734 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
52736 export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
52737 if(!isWasmInitialized) {
52738 throw new Error("initializeWasm() must be awaited first!");
52740 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
52741 return nativeResponseValue;
52743 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_paths(void);
52745 export function Bolt12SemanticError_unexpected_paths(): Bolt12SemanticError {
52746 if(!isWasmInitialized) {
52747 throw new Error("initializeWasm() must be awaited first!");
52749 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_paths();
52750 return nativeResponseValue;
52752 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
52754 export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
52755 if(!isWasmInitialized) {
52756 throw new Error("initializeWasm() must be awaited first!");
52758 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
52759 return nativeResponseValue;
52761 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
52763 export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
52764 if(!isWasmInitialized) {
52765 throw new Error("initializeWasm() must be awaited first!");
52767 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
52768 return nativeResponseValue;
52770 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
52772 export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
52773 if(!isWasmInitialized) {
52774 throw new Error("initializeWasm() must be awaited first!");
52776 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
52777 return nativeResponseValue;
52779 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
52781 export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
52782 if(!isWasmInitialized) {
52783 throw new Error("initializeWasm() must be awaited first!");
52785 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
52786 return nativeResponseValue;
52788 // void RefundMaybeWithDerivedMetadataBuilder_free(struct LDKRefundMaybeWithDerivedMetadataBuilder this_obj);
52790 export function RefundMaybeWithDerivedMetadataBuilder_free(this_obj: bigint): void {
52791 if(!isWasmInitialized) {
52792 throw new Error("initializeWasm() must be awaited first!");
52794 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_free(this_obj);
52795 // debug statements here
52797 // uint64_t RefundMaybeWithDerivedMetadataBuilder_clone_ptr(LDKRefundMaybeWithDerivedMetadataBuilder *NONNULL_PTR arg);
52799 export function RefundMaybeWithDerivedMetadataBuilder_clone_ptr(arg: bigint): bigint {
52800 if(!isWasmInitialized) {
52801 throw new Error("initializeWasm() must be awaited first!");
52803 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_clone_ptr(arg);
52804 return nativeResponseValue;
52806 // struct LDKRefundMaybeWithDerivedMetadataBuilder RefundMaybeWithDerivedMetadataBuilder_clone(const struct LDKRefundMaybeWithDerivedMetadataBuilder *NONNULL_PTR orig);
52808 export function RefundMaybeWithDerivedMetadataBuilder_clone(orig: bigint): bigint {
52809 if(!isWasmInitialized) {
52810 throw new Error("initializeWasm() must be awaited first!");
52812 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_clone(orig);
52813 return nativeResponseValue;
52815 // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_new(struct LDKCVec_u8Z metadata, struct LDKPublicKey payer_id, uint64_t amount_msats);
52817 export function RefundMaybeWithDerivedMetadataBuilder_new(metadata: number, payer_id: number, amount_msats: bigint): bigint {
52818 if(!isWasmInitialized) {
52819 throw new Error("initializeWasm() must be awaited first!");
52821 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_new(metadata, payer_id, amount_msats);
52822 return nativeResponseValue;
52824 // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(struct LDKPublicKey node_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKEntropySource entropy_source, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id);
52826 export function RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(node_id: number, expanded_key: bigint, entropy_source: bigint, amount_msats: bigint, payment_id: number): bigint {
52827 if(!isWasmInitialized) {
52828 throw new Error("initializeWasm() must be awaited first!");
52830 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(node_id, expanded_key, entropy_source, amount_msats, payment_id);
52831 return nativeResponseValue;
52833 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_description(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr description);
52835 export function RefundMaybeWithDerivedMetadataBuilder_description(this_arg: bigint, description: number): void {
52836 if(!isWasmInitialized) {
52837 throw new Error("initializeWasm() must be awaited first!");
52839 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_description(this_arg, description);
52840 // debug statements here
52842 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, uint64_t absolute_expiry);
52844 export function RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
52845 if(!isWasmInitialized) {
52846 throw new Error("initializeWasm() must be awaited first!");
52848 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
52849 // debug statements here
52851 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_issuer(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr issuer);
52853 export function RefundMaybeWithDerivedMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
52854 if(!isWasmInitialized) {
52855 throw new Error("initializeWasm() must be awaited first!");
52857 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_issuer(this_arg, issuer);
52858 // debug statements here
52860 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_path(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKBlindedPath path);
52862 export function RefundMaybeWithDerivedMetadataBuilder_path(this_arg: bigint, path: bigint): void {
52863 if(!isWasmInitialized) {
52864 throw new Error("initializeWasm() must be awaited first!");
52866 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_path(this_arg, path);
52867 // debug statements here
52869 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_chain(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, enum LDKNetwork network);
52871 export function RefundMaybeWithDerivedMetadataBuilder_chain(this_arg: bigint, network: Network): void {
52872 if(!isWasmInitialized) {
52873 throw new Error("initializeWasm() must be awaited first!");
52875 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_chain(this_arg, network);
52876 // debug statements here
52878 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_quantity(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, uint64_t quantity);
52880 export function RefundMaybeWithDerivedMetadataBuilder_quantity(this_arg: bigint, quantity: bigint): void {
52881 if(!isWasmInitialized) {
52882 throw new Error("initializeWasm() must be awaited first!");
52884 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_quantity(this_arg, quantity);
52885 // debug statements here
52887 // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_payer_note(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr payer_note);
52889 export function RefundMaybeWithDerivedMetadataBuilder_payer_note(this_arg: bigint, payer_note: number): void {
52890 if(!isWasmInitialized) {
52891 throw new Error("initializeWasm() must be awaited first!");
52893 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_payer_note(this_arg, payer_note);
52894 // debug statements here
52896 // MUST_USE_RES struct LDKCResult_RefundBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_build(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg);
52898 export function RefundMaybeWithDerivedMetadataBuilder_build(this_arg: bigint): bigint {
52899 if(!isWasmInitialized) {
52900 throw new Error("initializeWasm() must be awaited first!");
52902 const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_build(this_arg);
52903 return nativeResponseValue;
52905 // void Refund_free(struct LDKRefund this_obj);
52907 export function Refund_free(this_obj: bigint): void {
52908 if(!isWasmInitialized) {
52909 throw new Error("initializeWasm() must be awaited first!");
52911 const nativeResponseValue = wasm.TS_Refund_free(this_obj);
52912 // debug statements here
52914 // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
52916 export function Refund_clone_ptr(arg: bigint): bigint {
52917 if(!isWasmInitialized) {
52918 throw new Error("initializeWasm() must be awaited first!");
52920 const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
52921 return nativeResponseValue;
52923 // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
52925 export function Refund_clone(orig: bigint): bigint {
52926 if(!isWasmInitialized) {
52927 throw new Error("initializeWasm() must be awaited first!");
52929 const nativeResponseValue = wasm.TS_Refund_clone(orig);
52930 return nativeResponseValue;
52932 // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
52934 export function Refund_description(this_arg: bigint): bigint {
52935 if(!isWasmInitialized) {
52936 throw new Error("initializeWasm() must be awaited first!");
52938 const nativeResponseValue = wasm.TS_Refund_description(this_arg);
52939 return nativeResponseValue;
52941 // MUST_USE_RES struct LDKCOption_u64Z Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
52943 export function Refund_absolute_expiry(this_arg: bigint): bigint {
52944 if(!isWasmInitialized) {
52945 throw new Error("initializeWasm() must be awaited first!");
52947 const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
52948 return nativeResponseValue;
52950 // MUST_USE_RES bool Refund_is_expired_no_std(const struct LDKRefund *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
52952 export function Refund_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
52953 if(!isWasmInitialized) {
52954 throw new Error("initializeWasm() must be awaited first!");
52956 const nativeResponseValue = wasm.TS_Refund_is_expired_no_std(this_arg, duration_since_epoch);
52957 return nativeResponseValue;
52959 // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
52961 export function Refund_issuer(this_arg: bigint): bigint {
52962 if(!isWasmInitialized) {
52963 throw new Error("initializeWasm() must be awaited first!");
52965 const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
52966 return nativeResponseValue;
52968 // MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
52970 export function Refund_paths(this_arg: bigint): number {
52971 if(!isWasmInitialized) {
52972 throw new Error("initializeWasm() must be awaited first!");
52974 const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
52975 return nativeResponseValue;
52977 // MUST_USE_RES struct LDKu8slice Refund_payer_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
52979 export function Refund_payer_metadata(this_arg: bigint): number {
52980 if(!isWasmInitialized) {
52981 throw new Error("initializeWasm() must be awaited first!");
52983 const nativeResponseValue = wasm.TS_Refund_payer_metadata(this_arg);
52984 return nativeResponseValue;
52986 // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
52988 export function Refund_chain(this_arg: bigint): number {
52989 if(!isWasmInitialized) {
52990 throw new Error("initializeWasm() must be awaited first!");
52992 const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
52993 return nativeResponseValue;
52995 // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
52997 export function Refund_amount_msats(this_arg: bigint): bigint {
52998 if(!isWasmInitialized) {
52999 throw new Error("initializeWasm() must be awaited first!");
53001 const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
53002 return nativeResponseValue;
53004 // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
53006 export function Refund_features(this_arg: bigint): bigint {
53007 if(!isWasmInitialized) {
53008 throw new Error("initializeWasm() must be awaited first!");
53010 const nativeResponseValue = wasm.TS_Refund_features(this_arg);
53011 return nativeResponseValue;
53013 // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
53015 export function Refund_quantity(this_arg: bigint): bigint {
53016 if(!isWasmInitialized) {
53017 throw new Error("initializeWasm() must be awaited first!");
53019 const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
53020 return nativeResponseValue;
53022 // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
53024 export function Refund_payer_id(this_arg: bigint): number {
53025 if(!isWasmInitialized) {
53026 throw new Error("initializeWasm() must be awaited first!");
53028 const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
53029 return nativeResponseValue;
53031 // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
53033 export function Refund_payer_note(this_arg: bigint): bigint {
53034 if(!isWasmInitialized) {
53035 throw new Error("initializeWasm() must be awaited first!");
53037 const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
53038 return nativeResponseValue;
53040 // uint64_t Refund_hash(const struct LDKRefund *NONNULL_PTR o);
53042 export function Refund_hash(o: bigint): bigint {
53043 if(!isWasmInitialized) {
53044 throw new Error("initializeWasm() must be awaited first!");
53046 const nativeResponseValue = wasm.TS_Refund_hash(o);
53047 return nativeResponseValue;
53049 // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
53051 export function Refund_write(obj: bigint): number {
53052 if(!isWasmInitialized) {
53053 throw new Error("initializeWasm() must be awaited first!");
53055 const nativeResponseValue = wasm.TS_Refund_write(obj);
53056 return nativeResponseValue;
53058 // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
53060 export function Refund_from_str(s: number): bigint {
53061 if(!isWasmInitialized) {
53062 throw new Error("initializeWasm() must be awaited first!");
53064 const nativeResponseValue = wasm.TS_Refund_from_str(s);
53065 return nativeResponseValue;
53067 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
53069 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
53070 if(!isWasmInitialized) {
53071 throw new Error("initializeWasm() must be awaited first!");
53073 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
53074 return nativeResponseValue;
53076 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
53078 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
53079 if(!isWasmInitialized) {
53080 throw new Error("initializeWasm() must be awaited first!");
53082 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
53083 return nativeResponseValue;
53085 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
53087 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
53088 if(!isWasmInitialized) {
53089 throw new Error("initializeWasm() must be awaited first!");
53091 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
53092 return nativeResponseValue;
53094 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
53096 export function UtxoResult_free(this_ptr: bigint): void {
53097 if(!isWasmInitialized) {
53098 throw new Error("initializeWasm() must be awaited first!");
53100 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
53101 // debug statements here
53103 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
53105 export function UtxoResult_clone_ptr(arg: bigint): bigint {
53106 if(!isWasmInitialized) {
53107 throw new Error("initializeWasm() must be awaited first!");
53109 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
53110 return nativeResponseValue;
53112 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
53114 export function UtxoResult_clone(orig: bigint): bigint {
53115 if(!isWasmInitialized) {
53116 throw new Error("initializeWasm() must be awaited first!");
53118 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
53119 return nativeResponseValue;
53121 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
53123 export function UtxoResult_sync(a: bigint): bigint {
53124 if(!isWasmInitialized) {
53125 throw new Error("initializeWasm() must be awaited first!");
53127 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
53128 return nativeResponseValue;
53130 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
53132 export function UtxoResult_async(a: bigint): bigint {
53133 if(!isWasmInitialized) {
53134 throw new Error("initializeWasm() must be awaited first!");
53136 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
53137 return nativeResponseValue;
53139 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
53141 export function UtxoLookup_free(this_ptr: bigint): void {
53142 if(!isWasmInitialized) {
53143 throw new Error("initializeWasm() must be awaited first!");
53145 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
53146 // debug statements here
53148 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
53150 export function UtxoFuture_free(this_obj: bigint): void {
53151 if(!isWasmInitialized) {
53152 throw new Error("initializeWasm() must be awaited first!");
53154 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
53155 // debug statements here
53157 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
53159 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
53160 if(!isWasmInitialized) {
53161 throw new Error("initializeWasm() must be awaited first!");
53163 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
53164 return nativeResponseValue;
53166 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
53168 export function UtxoFuture_clone(orig: bigint): bigint {
53169 if(!isWasmInitialized) {
53170 throw new Error("initializeWasm() must be awaited first!");
53172 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
53173 return nativeResponseValue;
53175 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
53177 export function UtxoFuture_new(): bigint {
53178 if(!isWasmInitialized) {
53179 throw new Error("initializeWasm() must be awaited first!");
53181 const nativeResponseValue = wasm.TS_UtxoFuture_new();
53182 return nativeResponseValue;
53184 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
53186 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
53187 if(!isWasmInitialized) {
53188 throw new Error("initializeWasm() must be awaited first!");
53190 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
53191 // debug statements here
53193 // void UtxoFuture_resolve(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, const struct LDKP2PGossipSync *NONNULL_PTR gossip, struct LDKCResult_TxOutUtxoLookupErrorZ result);
53195 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
53196 if(!isWasmInitialized) {
53197 throw new Error("initializeWasm() must be awaited first!");
53199 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
53200 // debug statements here
53202 // void NodeId_free(struct LDKNodeId this_obj);
53204 export function NodeId_free(this_obj: bigint): void {
53205 if(!isWasmInitialized) {
53206 throw new Error("initializeWasm() must be awaited first!");
53208 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
53209 // debug statements here
53211 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
53213 export function NodeId_clone_ptr(arg: bigint): bigint {
53214 if(!isWasmInitialized) {
53215 throw new Error("initializeWasm() must be awaited first!");
53217 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
53218 return nativeResponseValue;
53220 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
53222 export function NodeId_clone(orig: bigint): bigint {
53223 if(!isWasmInitialized) {
53224 throw new Error("initializeWasm() must be awaited first!");
53226 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
53227 return nativeResponseValue;
53229 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
53231 export function NodeId_from_pubkey(pubkey: number): bigint {
53232 if(!isWasmInitialized) {
53233 throw new Error("initializeWasm() must be awaited first!");
53235 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
53236 return nativeResponseValue;
53238 // MUST_USE_RES struct LDKCResult_NodeIdDecodeErrorZ NodeId_from_slice(struct LDKu8slice bytes);
53240 export function NodeId_from_slice(bytes: number): bigint {
53241 if(!isWasmInitialized) {
53242 throw new Error("initializeWasm() must be awaited first!");
53244 const nativeResponseValue = wasm.TS_NodeId_from_slice(bytes);
53245 return nativeResponseValue;
53247 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
53249 export function NodeId_as_slice(this_arg: bigint): number {
53250 if(!isWasmInitialized) {
53251 throw new Error("initializeWasm() must be awaited first!");
53253 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
53254 return nativeResponseValue;
53256 // MUST_USE_RES const uint8_t (*NodeId_as_array(const struct LDKNodeId *NONNULL_PTR this_arg))[33];
53258 export function NodeId_as_array(this_arg: bigint): number {
53259 if(!isWasmInitialized) {
53260 throw new Error("initializeWasm() must be awaited first!");
53262 const nativeResponseValue = wasm.TS_NodeId_as_array(this_arg);
53263 return nativeResponseValue;
53265 // MUST_USE_RES struct LDKCResult_PublicKeySecp256k1ErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
53267 export function NodeId_as_pubkey(this_arg: bigint): bigint {
53268 if(!isWasmInitialized) {
53269 throw new Error("initializeWasm() must be awaited first!");
53271 const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
53272 return nativeResponseValue;
53274 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
53276 export function NodeId_hash(o: bigint): bigint {
53277 if(!isWasmInitialized) {
53278 throw new Error("initializeWasm() must be awaited first!");
53280 const nativeResponseValue = wasm.TS_NodeId_hash(o);
53281 return nativeResponseValue;
53283 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
53285 export function NodeId_write(obj: bigint): number {
53286 if(!isWasmInitialized) {
53287 throw new Error("initializeWasm() must be awaited first!");
53289 const nativeResponseValue = wasm.TS_NodeId_write(obj);
53290 return nativeResponseValue;
53292 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
53294 export function NodeId_read(ser: number): bigint {
53295 if(!isWasmInitialized) {
53296 throw new Error("initializeWasm() must be awaited first!");
53298 const nativeResponseValue = wasm.TS_NodeId_read(ser);
53299 return nativeResponseValue;
53301 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
53303 export function NetworkGraph_free(this_obj: bigint): void {
53304 if(!isWasmInitialized) {
53305 throw new Error("initializeWasm() must be awaited first!");
53307 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
53308 // debug statements here
53310 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
53312 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
53313 if(!isWasmInitialized) {
53314 throw new Error("initializeWasm() must be awaited first!");
53316 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
53317 // debug statements here
53319 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
53321 export function NetworkUpdate_free(this_ptr: bigint): void {
53322 if(!isWasmInitialized) {
53323 throw new Error("initializeWasm() must be awaited first!");
53325 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
53326 // debug statements here
53328 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
53330 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
53331 if(!isWasmInitialized) {
53332 throw new Error("initializeWasm() must be awaited first!");
53334 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
53335 return nativeResponseValue;
53337 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
53339 export function NetworkUpdate_clone(orig: bigint): bigint {
53340 if(!isWasmInitialized) {
53341 throw new Error("initializeWasm() must be awaited first!");
53343 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
53344 return nativeResponseValue;
53346 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
53348 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
53349 if(!isWasmInitialized) {
53350 throw new Error("initializeWasm() must be awaited first!");
53352 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
53353 return nativeResponseValue;
53355 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
53357 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
53358 if(!isWasmInitialized) {
53359 throw new Error("initializeWasm() must be awaited first!");
53361 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
53362 return nativeResponseValue;
53364 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
53366 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
53367 if(!isWasmInitialized) {
53368 throw new Error("initializeWasm() must be awaited first!");
53370 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
53371 return nativeResponseValue;
53373 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
53375 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
53376 if(!isWasmInitialized) {
53377 throw new Error("initializeWasm() must be awaited first!");
53379 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
53380 return nativeResponseValue;
53382 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
53384 export function NetworkUpdate_write(obj: bigint): number {
53385 if(!isWasmInitialized) {
53386 throw new Error("initializeWasm() must be awaited first!");
53388 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
53389 return nativeResponseValue;
53391 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
53393 export function NetworkUpdate_read(ser: number): bigint {
53394 if(!isWasmInitialized) {
53395 throw new Error("initializeWasm() must be awaited first!");
53397 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
53398 return nativeResponseValue;
53400 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
53402 export function P2PGossipSync_free(this_obj: bigint): void {
53403 if(!isWasmInitialized) {
53404 throw new Error("initializeWasm() must be awaited first!");
53406 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
53407 // debug statements here
53409 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
53411 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
53412 if(!isWasmInitialized) {
53413 throw new Error("initializeWasm() must be awaited first!");
53415 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
53416 return nativeResponseValue;
53418 // void P2PGossipSync_add_utxo_lookup(const struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
53420 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
53421 if(!isWasmInitialized) {
53422 throw new Error("initializeWasm() must be awaited first!");
53424 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
53425 // debug statements here
53427 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
53429 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
53430 if(!isWasmInitialized) {
53431 throw new Error("initializeWasm() must be awaited first!");
53433 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
53434 // debug statements here
53436 // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_chain_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
53438 export function NetworkGraph_get_chain_hash(this_arg: bigint): number {
53439 if(!isWasmInitialized) {
53440 throw new Error("initializeWasm() must be awaited first!");
53442 const nativeResponseValue = wasm.TS_NetworkGraph_get_chain_hash(this_arg);
53443 return nativeResponseValue;
53445 // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
53447 export function verify_node_announcement(msg: bigint): bigint {
53448 if(!isWasmInitialized) {
53449 throw new Error("initializeWasm() must be awaited first!");
53451 const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
53452 return nativeResponseValue;
53454 // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
53456 export function verify_channel_announcement(msg: bigint): bigint {
53457 if(!isWasmInitialized) {
53458 throw new Error("initializeWasm() must be awaited first!");
53460 const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
53461 return nativeResponseValue;
53463 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
53465 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
53466 if(!isWasmInitialized) {
53467 throw new Error("initializeWasm() must be awaited first!");
53469 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
53470 return nativeResponseValue;
53472 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
53474 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
53475 if(!isWasmInitialized) {
53476 throw new Error("initializeWasm() must be awaited first!");
53478 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
53479 return nativeResponseValue;
53481 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
53483 export function ChannelUpdateInfo_free(this_obj: bigint): void {
53484 if(!isWasmInitialized) {
53485 throw new Error("initializeWasm() must be awaited first!");
53487 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
53488 // debug statements here
53490 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53492 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
53493 if(!isWasmInitialized) {
53494 throw new Error("initializeWasm() must be awaited first!");
53496 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
53497 return nativeResponseValue;
53499 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
53501 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
53502 if(!isWasmInitialized) {
53503 throw new Error("initializeWasm() must be awaited first!");
53505 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
53506 // debug statements here
53508 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53510 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
53511 if(!isWasmInitialized) {
53512 throw new Error("initializeWasm() must be awaited first!");
53514 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
53515 return nativeResponseValue;
53517 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
53519 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
53520 if(!isWasmInitialized) {
53521 throw new Error("initializeWasm() must be awaited first!");
53523 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
53524 // debug statements here
53526 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53528 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
53529 if(!isWasmInitialized) {
53530 throw new Error("initializeWasm() must be awaited first!");
53532 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
53533 return nativeResponseValue;
53535 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
53537 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
53538 if(!isWasmInitialized) {
53539 throw new Error("initializeWasm() must be awaited first!");
53541 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
53542 // debug statements here
53544 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53546 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
53547 if(!isWasmInitialized) {
53548 throw new Error("initializeWasm() must be awaited first!");
53550 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
53551 return nativeResponseValue;
53553 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
53555 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
53556 if(!isWasmInitialized) {
53557 throw new Error("initializeWasm() must be awaited first!");
53559 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
53560 // debug statements here
53562 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53564 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
53565 if(!isWasmInitialized) {
53566 throw new Error("initializeWasm() must be awaited first!");
53568 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
53569 return nativeResponseValue;
53571 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
53573 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
53574 if(!isWasmInitialized) {
53575 throw new Error("initializeWasm() must be awaited first!");
53577 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
53578 // debug statements here
53580 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53582 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
53583 if(!isWasmInitialized) {
53584 throw new Error("initializeWasm() must be awaited first!");
53586 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
53587 return nativeResponseValue;
53589 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
53591 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
53592 if(!isWasmInitialized) {
53593 throw new Error("initializeWasm() must be awaited first!");
53595 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
53596 // debug statements here
53598 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
53600 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
53601 if(!isWasmInitialized) {
53602 throw new Error("initializeWasm() must be awaited first!");
53604 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
53605 return nativeResponseValue;
53607 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
53609 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
53610 if(!isWasmInitialized) {
53611 throw new Error("initializeWasm() must be awaited first!");
53613 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
53614 // debug statements here
53616 // 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);
53618 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 {
53619 if(!isWasmInitialized) {
53620 throw new Error("initializeWasm() must be awaited first!");
53622 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);
53623 return nativeResponseValue;
53625 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
53627 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
53628 if(!isWasmInitialized) {
53629 throw new Error("initializeWasm() must be awaited first!");
53631 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
53632 return nativeResponseValue;
53634 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
53636 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
53637 if(!isWasmInitialized) {
53638 throw new Error("initializeWasm() must be awaited first!");
53640 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
53641 return nativeResponseValue;
53643 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
53645 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
53646 if(!isWasmInitialized) {
53647 throw new Error("initializeWasm() must be awaited first!");
53649 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
53650 return nativeResponseValue;
53652 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
53654 export function ChannelUpdateInfo_write(obj: bigint): number {
53655 if(!isWasmInitialized) {
53656 throw new Error("initializeWasm() must be awaited first!");
53658 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
53659 return nativeResponseValue;
53661 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
53663 export function ChannelUpdateInfo_read(ser: number): bigint {
53664 if(!isWasmInitialized) {
53665 throw new Error("initializeWasm() must be awaited first!");
53667 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
53668 return nativeResponseValue;
53670 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
53672 export function ChannelInfo_free(this_obj: bigint): void {
53673 if(!isWasmInitialized) {
53674 throw new Error("initializeWasm() must be awaited first!");
53676 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
53677 // debug statements here
53679 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53681 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
53682 if(!isWasmInitialized) {
53683 throw new Error("initializeWasm() must be awaited first!");
53685 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
53686 return nativeResponseValue;
53688 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
53690 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
53691 if(!isWasmInitialized) {
53692 throw new Error("initializeWasm() must be awaited first!");
53694 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
53695 // debug statements here
53697 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53699 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
53700 if(!isWasmInitialized) {
53701 throw new Error("initializeWasm() must be awaited first!");
53703 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
53704 return nativeResponseValue;
53706 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
53708 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
53709 if(!isWasmInitialized) {
53710 throw new Error("initializeWasm() must be awaited first!");
53712 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
53713 // debug statements here
53715 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53717 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
53718 if(!isWasmInitialized) {
53719 throw new Error("initializeWasm() must be awaited first!");
53721 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
53722 return nativeResponseValue;
53724 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
53726 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
53727 if(!isWasmInitialized) {
53728 throw new Error("initializeWasm() must be awaited first!");
53730 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
53731 // debug statements here
53733 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53735 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
53736 if(!isWasmInitialized) {
53737 throw new Error("initializeWasm() must be awaited first!");
53739 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
53740 return nativeResponseValue;
53742 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
53744 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
53745 if(!isWasmInitialized) {
53746 throw new Error("initializeWasm() must be awaited first!");
53748 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
53749 // debug statements here
53751 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53753 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
53754 if(!isWasmInitialized) {
53755 throw new Error("initializeWasm() must be awaited first!");
53757 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
53758 return nativeResponseValue;
53760 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
53762 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
53763 if(!isWasmInitialized) {
53764 throw new Error("initializeWasm() must be awaited first!");
53766 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
53767 // debug statements here
53769 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53771 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
53772 if(!isWasmInitialized) {
53773 throw new Error("initializeWasm() must be awaited first!");
53775 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
53776 return nativeResponseValue;
53778 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
53780 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
53781 if(!isWasmInitialized) {
53782 throw new Error("initializeWasm() must be awaited first!");
53784 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
53785 // debug statements here
53787 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
53789 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
53790 if(!isWasmInitialized) {
53791 throw new Error("initializeWasm() must be awaited first!");
53793 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
53794 return nativeResponseValue;
53796 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
53798 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
53799 if(!isWasmInitialized) {
53800 throw new Error("initializeWasm() must be awaited first!");
53802 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
53803 // debug statements here
53805 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
53807 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
53808 if(!isWasmInitialized) {
53809 throw new Error("initializeWasm() must be awaited first!");
53811 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
53812 return nativeResponseValue;
53814 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
53816 export function ChannelInfo_clone(orig: bigint): bigint {
53817 if(!isWasmInitialized) {
53818 throw new Error("initializeWasm() must be awaited first!");
53820 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
53821 return nativeResponseValue;
53823 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
53825 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
53826 if(!isWasmInitialized) {
53827 throw new Error("initializeWasm() must be awaited first!");
53829 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
53830 return nativeResponseValue;
53832 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
53834 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
53835 if(!isWasmInitialized) {
53836 throw new Error("initializeWasm() must be awaited first!");
53838 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
53839 return nativeResponseValue;
53841 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
53843 export function ChannelInfo_write(obj: bigint): number {
53844 if(!isWasmInitialized) {
53845 throw new Error("initializeWasm() must be awaited first!");
53847 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
53848 return nativeResponseValue;
53850 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
53852 export function ChannelInfo_read(ser: number): bigint {
53853 if(!isWasmInitialized) {
53854 throw new Error("initializeWasm() must be awaited first!");
53856 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
53857 return nativeResponseValue;
53859 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
53861 export function DirectedChannelInfo_free(this_obj: bigint): void {
53862 if(!isWasmInitialized) {
53863 throw new Error("initializeWasm() must be awaited first!");
53865 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
53866 // debug statements here
53868 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
53870 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
53871 if(!isWasmInitialized) {
53872 throw new Error("initializeWasm() must be awaited first!");
53874 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
53875 return nativeResponseValue;
53877 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
53879 export function DirectedChannelInfo_clone(orig: bigint): bigint {
53880 if(!isWasmInitialized) {
53881 throw new Error("initializeWasm() must be awaited first!");
53883 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
53884 return nativeResponseValue;
53886 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
53888 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
53889 if(!isWasmInitialized) {
53890 throw new Error("initializeWasm() must be awaited first!");
53892 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
53893 return nativeResponseValue;
53895 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
53897 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
53898 if(!isWasmInitialized) {
53899 throw new Error("initializeWasm() must be awaited first!");
53901 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
53902 return nativeResponseValue;
53904 // MUST_USE_RES struct LDKNodeId DirectedChannelInfo_source(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
53906 export function DirectedChannelInfo_source(this_arg: bigint): bigint {
53907 if(!isWasmInitialized) {
53908 throw new Error("initializeWasm() must be awaited first!");
53910 const nativeResponseValue = wasm.TS_DirectedChannelInfo_source(this_arg);
53911 return nativeResponseValue;
53913 // MUST_USE_RES struct LDKNodeId DirectedChannelInfo_target(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
53915 export function DirectedChannelInfo_target(this_arg: bigint): bigint {
53916 if(!isWasmInitialized) {
53917 throw new Error("initializeWasm() must be awaited first!");
53919 const nativeResponseValue = wasm.TS_DirectedChannelInfo_target(this_arg);
53920 return nativeResponseValue;
53922 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
53924 export function EffectiveCapacity_free(this_ptr: bigint): void {
53925 if(!isWasmInitialized) {
53926 throw new Error("initializeWasm() must be awaited first!");
53928 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
53929 // debug statements here
53931 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
53933 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
53934 if(!isWasmInitialized) {
53935 throw new Error("initializeWasm() must be awaited first!");
53937 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
53938 return nativeResponseValue;
53940 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
53942 export function EffectiveCapacity_clone(orig: bigint): bigint {
53943 if(!isWasmInitialized) {
53944 throw new Error("initializeWasm() must be awaited first!");
53946 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
53947 return nativeResponseValue;
53949 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
53951 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
53952 if(!isWasmInitialized) {
53953 throw new Error("initializeWasm() must be awaited first!");
53955 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
53956 return nativeResponseValue;
53958 // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
53960 export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
53961 if(!isWasmInitialized) {
53962 throw new Error("initializeWasm() must be awaited first!");
53964 const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
53965 return nativeResponseValue;
53967 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
53969 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
53970 if(!isWasmInitialized) {
53971 throw new Error("initializeWasm() must be awaited first!");
53973 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
53974 return nativeResponseValue;
53976 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
53978 export function EffectiveCapacity_infinite(): bigint {
53979 if(!isWasmInitialized) {
53980 throw new Error("initializeWasm() must be awaited first!");
53982 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
53983 return nativeResponseValue;
53985 // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
53987 export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
53988 if(!isWasmInitialized) {
53989 throw new Error("initializeWasm() must be awaited first!");
53991 const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
53992 return nativeResponseValue;
53994 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
53996 export function EffectiveCapacity_unknown(): bigint {
53997 if(!isWasmInitialized) {
53998 throw new Error("initializeWasm() must be awaited first!");
54000 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
54001 return nativeResponseValue;
54003 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
54005 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
54006 if(!isWasmInitialized) {
54007 throw new Error("initializeWasm() must be awaited first!");
54009 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
54010 return nativeResponseValue;
54012 // void RoutingFees_free(struct LDKRoutingFees this_obj);
54014 export function RoutingFees_free(this_obj: bigint): void {
54015 if(!isWasmInitialized) {
54016 throw new Error("initializeWasm() must be awaited first!");
54018 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
54019 // debug statements here
54021 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
54023 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
54024 if(!isWasmInitialized) {
54025 throw new Error("initializeWasm() must be awaited first!");
54027 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
54028 return nativeResponseValue;
54030 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
54032 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
54033 if(!isWasmInitialized) {
54034 throw new Error("initializeWasm() must be awaited first!");
54036 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
54037 // debug statements here
54039 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
54041 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
54042 if(!isWasmInitialized) {
54043 throw new Error("initializeWasm() must be awaited first!");
54045 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
54046 return nativeResponseValue;
54048 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
54050 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
54051 if(!isWasmInitialized) {
54052 throw new Error("initializeWasm() must be awaited first!");
54054 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
54055 // debug statements here
54057 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
54059 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
54060 if(!isWasmInitialized) {
54061 throw new Error("initializeWasm() must be awaited first!");
54063 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
54064 return nativeResponseValue;
54066 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
54068 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
54069 if(!isWasmInitialized) {
54070 throw new Error("initializeWasm() must be awaited first!");
54072 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
54073 return nativeResponseValue;
54075 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
54077 export function RoutingFees_clone_ptr(arg: bigint): bigint {
54078 if(!isWasmInitialized) {
54079 throw new Error("initializeWasm() must be awaited first!");
54081 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
54082 return nativeResponseValue;
54084 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
54086 export function RoutingFees_clone(orig: bigint): bigint {
54087 if(!isWasmInitialized) {
54088 throw new Error("initializeWasm() must be awaited first!");
54090 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
54091 return nativeResponseValue;
54093 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
54095 export function RoutingFees_hash(o: bigint): bigint {
54096 if(!isWasmInitialized) {
54097 throw new Error("initializeWasm() must be awaited first!");
54099 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
54100 return nativeResponseValue;
54102 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
54104 export function RoutingFees_write(obj: bigint): number {
54105 if(!isWasmInitialized) {
54106 throw new Error("initializeWasm() must be awaited first!");
54108 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
54109 return nativeResponseValue;
54111 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
54113 export function RoutingFees_read(ser: number): bigint {
54114 if(!isWasmInitialized) {
54115 throw new Error("initializeWasm() must be awaited first!");
54117 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
54118 return nativeResponseValue;
54120 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
54122 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
54123 if(!isWasmInitialized) {
54124 throw new Error("initializeWasm() must be awaited first!");
54126 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
54127 // debug statements here
54129 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
54131 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
54132 if(!isWasmInitialized) {
54133 throw new Error("initializeWasm() must be awaited first!");
54135 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
54136 return nativeResponseValue;
54138 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
54140 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
54141 if(!isWasmInitialized) {
54142 throw new Error("initializeWasm() must be awaited first!");
54144 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
54145 // debug statements here
54147 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
54149 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
54150 if(!isWasmInitialized) {
54151 throw new Error("initializeWasm() must be awaited first!");
54153 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
54154 return nativeResponseValue;
54156 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
54158 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
54159 if(!isWasmInitialized) {
54160 throw new Error("initializeWasm() must be awaited first!");
54162 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
54163 // debug statements here
54165 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
54167 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
54168 if(!isWasmInitialized) {
54169 throw new Error("initializeWasm() must be awaited first!");
54171 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
54172 return nativeResponseValue;
54174 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
54176 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
54177 if(!isWasmInitialized) {
54178 throw new Error("initializeWasm() must be awaited first!");
54180 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
54181 // debug statements here
54183 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
54185 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
54186 if(!isWasmInitialized) {
54187 throw new Error("initializeWasm() must be awaited first!");
54189 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
54190 return nativeResponseValue;
54192 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
54194 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
54195 if(!isWasmInitialized) {
54196 throw new Error("initializeWasm() must be awaited first!");
54198 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
54199 // debug statements here
54201 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
54203 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
54204 if(!isWasmInitialized) {
54205 throw new Error("initializeWasm() must be awaited first!");
54207 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
54208 return nativeResponseValue;
54210 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
54212 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
54213 if(!isWasmInitialized) {
54214 throw new Error("initializeWasm() must be awaited first!");
54216 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
54217 // debug statements here
54219 // 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 LDKNodeAnnouncement announcement_message_arg);
54221 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
54222 if(!isWasmInitialized) {
54223 throw new Error("initializeWasm() must be awaited first!");
54225 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
54226 return nativeResponseValue;
54228 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
54230 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
54231 if(!isWasmInitialized) {
54232 throw new Error("initializeWasm() must be awaited first!");
54234 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
54235 return nativeResponseValue;
54237 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
54239 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
54240 if(!isWasmInitialized) {
54241 throw new Error("initializeWasm() must be awaited first!");
54243 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
54244 return nativeResponseValue;
54246 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
54248 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
54249 if(!isWasmInitialized) {
54250 throw new Error("initializeWasm() must be awaited first!");
54252 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
54253 return nativeResponseValue;
54255 // MUST_USE_RES struct LDKCVec_SocketAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
54257 export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
54258 if(!isWasmInitialized) {
54259 throw new Error("initializeWasm() must be awaited first!");
54261 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
54262 return nativeResponseValue;
54264 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
54266 export function NodeAnnouncementInfo_write(obj: bigint): number {
54267 if(!isWasmInitialized) {
54268 throw new Error("initializeWasm() must be awaited first!");
54270 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
54271 return nativeResponseValue;
54273 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
54275 export function NodeAnnouncementInfo_read(ser: number): bigint {
54276 if(!isWasmInitialized) {
54277 throw new Error("initializeWasm() must be awaited first!");
54279 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
54280 return nativeResponseValue;
54282 // void NodeAlias_free(struct LDKNodeAlias this_obj);
54284 export function NodeAlias_free(this_obj: bigint): void {
54285 if(!isWasmInitialized) {
54286 throw new Error("initializeWasm() must be awaited first!");
54288 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
54289 // debug statements here
54291 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
54293 export function NodeAlias_get_a(this_ptr: bigint): number {
54294 if(!isWasmInitialized) {
54295 throw new Error("initializeWasm() must be awaited first!");
54297 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
54298 return nativeResponseValue;
54300 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
54302 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
54303 if(!isWasmInitialized) {
54304 throw new Error("initializeWasm() must be awaited first!");
54306 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
54307 // debug statements here
54309 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
54311 export function NodeAlias_new(a_arg: number): bigint {
54312 if(!isWasmInitialized) {
54313 throw new Error("initializeWasm() must be awaited first!");
54315 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
54316 return nativeResponseValue;
54318 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
54320 export function NodeAlias_clone_ptr(arg: bigint): bigint {
54321 if(!isWasmInitialized) {
54322 throw new Error("initializeWasm() must be awaited first!");
54324 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
54325 return nativeResponseValue;
54327 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
54329 export function NodeAlias_clone(orig: bigint): bigint {
54330 if(!isWasmInitialized) {
54331 throw new Error("initializeWasm() must be awaited first!");
54333 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
54334 return nativeResponseValue;
54336 // uint64_t NodeAlias_hash(const struct LDKNodeAlias *NONNULL_PTR o);
54338 export function NodeAlias_hash(o: bigint): bigint {
54339 if(!isWasmInitialized) {
54340 throw new Error("initializeWasm() must be awaited first!");
54342 const nativeResponseValue = wasm.TS_NodeAlias_hash(o);
54343 return nativeResponseValue;
54345 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
54347 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
54348 if(!isWasmInitialized) {
54349 throw new Error("initializeWasm() must be awaited first!");
54351 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
54352 return nativeResponseValue;
54354 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
54356 export function NodeAlias_write(obj: bigint): number {
54357 if(!isWasmInitialized) {
54358 throw new Error("initializeWasm() must be awaited first!");
54360 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
54361 return nativeResponseValue;
54363 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
54365 export function NodeAlias_read(ser: number): bigint {
54366 if(!isWasmInitialized) {
54367 throw new Error("initializeWasm() must be awaited first!");
54369 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
54370 return nativeResponseValue;
54372 // void NodeInfo_free(struct LDKNodeInfo this_obj);
54374 export function NodeInfo_free(this_obj: bigint): void {
54375 if(!isWasmInitialized) {
54376 throw new Error("initializeWasm() must be awaited first!");
54378 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
54379 // debug statements here
54381 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
54383 export function NodeInfo_get_channels(this_ptr: bigint): number {
54384 if(!isWasmInitialized) {
54385 throw new Error("initializeWasm() must be awaited first!");
54387 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
54388 return nativeResponseValue;
54390 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
54392 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
54393 if(!isWasmInitialized) {
54394 throw new Error("initializeWasm() must be awaited first!");
54396 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
54397 // debug statements here
54399 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
54401 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
54402 if(!isWasmInitialized) {
54403 throw new Error("initializeWasm() must be awaited first!");
54405 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
54406 return nativeResponseValue;
54408 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
54410 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
54411 if(!isWasmInitialized) {
54412 throw new Error("initializeWasm() must be awaited first!");
54414 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
54415 // debug statements here
54417 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
54419 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
54420 if(!isWasmInitialized) {
54421 throw new Error("initializeWasm() must be awaited first!");
54423 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
54424 return nativeResponseValue;
54426 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
54428 export function NodeInfo_clone_ptr(arg: bigint): bigint {
54429 if(!isWasmInitialized) {
54430 throw new Error("initializeWasm() must be awaited first!");
54432 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
54433 return nativeResponseValue;
54435 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
54437 export function NodeInfo_clone(orig: bigint): bigint {
54438 if(!isWasmInitialized) {
54439 throw new Error("initializeWasm() must be awaited first!");
54441 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
54442 return nativeResponseValue;
54444 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
54446 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
54447 if(!isWasmInitialized) {
54448 throw new Error("initializeWasm() must be awaited first!");
54450 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
54451 return nativeResponseValue;
54453 // MUST_USE_RES bool NodeInfo_is_tor_only(const struct LDKNodeInfo *NONNULL_PTR this_arg);
54455 export function NodeInfo_is_tor_only(this_arg: bigint): boolean {
54456 if(!isWasmInitialized) {
54457 throw new Error("initializeWasm() must be awaited first!");
54459 const nativeResponseValue = wasm.TS_NodeInfo_is_tor_only(this_arg);
54460 return nativeResponseValue;
54462 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
54464 export function NodeInfo_write(obj: bigint): number {
54465 if(!isWasmInitialized) {
54466 throw new Error("initializeWasm() must be awaited first!");
54468 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
54469 return nativeResponseValue;
54471 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
54473 export function NodeInfo_read(ser: number): bigint {
54474 if(!isWasmInitialized) {
54475 throw new Error("initializeWasm() must be awaited first!");
54477 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
54478 return nativeResponseValue;
54480 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
54482 export function NetworkGraph_write(obj: bigint): number {
54483 if(!isWasmInitialized) {
54484 throw new Error("initializeWasm() must be awaited first!");
54486 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
54487 return nativeResponseValue;
54489 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
54491 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
54492 if(!isWasmInitialized) {
54493 throw new Error("initializeWasm() must be awaited first!");
54495 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
54496 return nativeResponseValue;
54498 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
54500 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
54501 if(!isWasmInitialized) {
54502 throw new Error("initializeWasm() must be awaited first!");
54504 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
54505 return nativeResponseValue;
54507 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
54509 export function NetworkGraph_read_only(this_arg: bigint): bigint {
54510 if(!isWasmInitialized) {
54511 throw new Error("initializeWasm() must be awaited first!");
54513 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
54514 return nativeResponseValue;
54516 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
54518 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
54519 if(!isWasmInitialized) {
54520 throw new Error("initializeWasm() must be awaited first!");
54522 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
54523 return nativeResponseValue;
54525 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
54527 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
54528 if(!isWasmInitialized) {
54529 throw new Error("initializeWasm() must be awaited first!");
54531 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
54532 // debug statements here
54534 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
54536 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
54537 if(!isWasmInitialized) {
54538 throw new Error("initializeWasm() must be awaited first!");
54540 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
54541 return nativeResponseValue;
54543 // 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);
54545 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
54546 if(!isWasmInitialized) {
54547 throw new Error("initializeWasm() must be awaited first!");
54549 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
54550 return nativeResponseValue;
54552 // 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_UtxoLookupZ utxo_lookup);
54554 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
54555 if(!isWasmInitialized) {
54556 throw new Error("initializeWasm() must be awaited first!");
54558 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
54559 return nativeResponseValue;
54561 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement_no_lookup(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg);
54563 export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
54564 if(!isWasmInitialized) {
54565 throw new Error("initializeWasm() must be awaited first!");
54567 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
54568 return nativeResponseValue;
54570 // 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_UtxoLookupZ utxo_lookup);
54572 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
54573 if(!isWasmInitialized) {
54574 throw new Error("initializeWasm() must be awaited first!");
54576 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
54577 return nativeResponseValue;
54579 // 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);
54581 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 {
54582 if(!isWasmInitialized) {
54583 throw new Error("initializeWasm() must be awaited first!");
54585 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
54586 return nativeResponseValue;
54588 // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
54590 export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
54591 if(!isWasmInitialized) {
54592 throw new Error("initializeWasm() must be awaited first!");
54594 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
54595 // debug statements here
54597 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
54599 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
54600 if(!isWasmInitialized) {
54601 throw new Error("initializeWasm() must be awaited first!");
54603 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
54604 // debug statements here
54606 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
54608 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
54609 if(!isWasmInitialized) {
54610 throw new Error("initializeWasm() must be awaited first!");
54612 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
54613 // debug statements here
54615 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
54617 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
54618 if(!isWasmInitialized) {
54619 throw new Error("initializeWasm() must be awaited first!");
54621 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
54622 return nativeResponseValue;
54624 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
54626 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
54627 if(!isWasmInitialized) {
54628 throw new Error("initializeWasm() must be awaited first!");
54630 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
54631 return nativeResponseValue;
54633 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_verify_channel_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
54635 export function NetworkGraph_verify_channel_update(this_arg: bigint, msg: bigint): bigint {
54636 if(!isWasmInitialized) {
54637 throw new Error("initializeWasm() must be awaited first!");
54639 const nativeResponseValue = wasm.TS_NetworkGraph_verify_channel_update(this_arg, msg);
54640 return nativeResponseValue;
54642 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
54644 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
54645 if(!isWasmInitialized) {
54646 throw new Error("initializeWasm() must be awaited first!");
54648 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
54649 return nativeResponseValue;
54651 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
54653 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
54654 if(!isWasmInitialized) {
54655 throw new Error("initializeWasm() must be awaited first!");
54657 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
54658 return nativeResponseValue;
54660 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
54662 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
54663 if(!isWasmInitialized) {
54664 throw new Error("initializeWasm() must be awaited first!");
54666 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
54667 return nativeResponseValue;
54669 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
54671 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
54672 if(!isWasmInitialized) {
54673 throw new Error("initializeWasm() must be awaited first!");
54675 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
54676 return nativeResponseValue;
54678 // MUST_USE_RES struct LDKCOption_CVec_SocketAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
54680 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
54681 if(!isWasmInitialized) {
54682 throw new Error("initializeWasm() must be awaited first!");
54684 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
54685 return nativeResponseValue;
54687 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
54689 export function DefaultRouter_free(this_obj: bigint): void {
54690 if(!isWasmInitialized) {
54691 throw new Error("initializeWasm() must be awaited first!");
54693 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
54694 // debug statements here
54696 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKLockableScore scorer, struct LDKProbabilisticScoringFeeParameters score_params);
54698 export function DefaultRouter_new(network_graph: bigint, logger: bigint, entropy_source: bigint, scorer: bigint, score_params: bigint): bigint {
54699 if(!isWasmInitialized) {
54700 throw new Error("initializeWasm() must be awaited first!");
54702 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, entropy_source, scorer, score_params);
54703 return nativeResponseValue;
54705 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
54707 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
54708 if(!isWasmInitialized) {
54709 throw new Error("initializeWasm() must be awaited first!");
54711 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
54712 return nativeResponseValue;
54714 // struct LDKMessageRouter DefaultRouter_as_MessageRouter(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
54716 export function DefaultRouter_as_MessageRouter(this_arg: bigint): bigint {
54717 if(!isWasmInitialized) {
54718 throw new Error("initializeWasm() must be awaited first!");
54720 const nativeResponseValue = wasm.TS_DefaultRouter_as_MessageRouter(this_arg);
54721 return nativeResponseValue;
54723 // void Router_free(struct LDKRouter this_ptr);
54725 export function Router_free(this_ptr: bigint): void {
54726 if(!isWasmInitialized) {
54727 throw new Error("initializeWasm() must be awaited first!");
54729 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
54730 // debug statements here
54732 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
54734 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
54735 if(!isWasmInitialized) {
54736 throw new Error("initializeWasm() must be awaited first!");
54738 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
54739 // debug statements here
54741 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScoreLookUp scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
54743 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
54744 if(!isWasmInitialized) {
54745 throw new Error("initializeWasm() must be awaited first!");
54747 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
54748 return nativeResponseValue;
54750 // struct LDKScoreLookUp ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
54752 export function ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg: bigint): bigint {
54753 if(!isWasmInitialized) {
54754 throw new Error("initializeWasm() must be awaited first!");
54756 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg);
54757 return nativeResponseValue;
54759 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
54761 export function InFlightHtlcs_free(this_obj: bigint): void {
54762 if(!isWasmInitialized) {
54763 throw new Error("initializeWasm() must be awaited first!");
54765 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
54766 // debug statements here
54768 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
54770 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
54771 if(!isWasmInitialized) {
54772 throw new Error("initializeWasm() must be awaited first!");
54774 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
54775 return nativeResponseValue;
54777 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
54779 export function InFlightHtlcs_clone(orig: bigint): bigint {
54780 if(!isWasmInitialized) {
54781 throw new Error("initializeWasm() must be awaited first!");
54783 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
54784 return nativeResponseValue;
54786 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
54788 export function InFlightHtlcs_new(): bigint {
54789 if(!isWasmInitialized) {
54790 throw new Error("initializeWasm() must be awaited first!");
54792 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
54793 return nativeResponseValue;
54795 // void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
54797 export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
54798 if(!isWasmInitialized) {
54799 throw new Error("initializeWasm() must be awaited first!");
54801 const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
54802 // debug statements here
54804 // void InFlightHtlcs_add_inflight_htlc(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid, uint64_t used_msat);
54806 export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
54807 if(!isWasmInitialized) {
54808 throw new Error("initializeWasm() must be awaited first!");
54810 const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
54811 // debug statements here
54813 // 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);
54815 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
54816 if(!isWasmInitialized) {
54817 throw new Error("initializeWasm() must be awaited first!");
54819 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
54820 return nativeResponseValue;
54822 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
54824 export function InFlightHtlcs_write(obj: bigint): number {
54825 if(!isWasmInitialized) {
54826 throw new Error("initializeWasm() must be awaited first!");
54828 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
54829 return nativeResponseValue;
54831 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
54833 export function InFlightHtlcs_read(ser: number): bigint {
54834 if(!isWasmInitialized) {
54835 throw new Error("initializeWasm() must be awaited first!");
54837 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
54838 return nativeResponseValue;
54840 // void RouteHop_free(struct LDKRouteHop this_obj);
54842 export function RouteHop_free(this_obj: bigint): void {
54843 if(!isWasmInitialized) {
54844 throw new Error("initializeWasm() must be awaited first!");
54846 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
54847 // debug statements here
54849 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54851 export function RouteHop_get_pubkey(this_ptr: bigint): number {
54852 if(!isWasmInitialized) {
54853 throw new Error("initializeWasm() must be awaited first!");
54855 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
54856 return nativeResponseValue;
54858 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
54860 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
54861 if(!isWasmInitialized) {
54862 throw new Error("initializeWasm() must be awaited first!");
54864 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
54865 // debug statements here
54867 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54869 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
54870 if(!isWasmInitialized) {
54871 throw new Error("initializeWasm() must be awaited first!");
54873 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
54874 return nativeResponseValue;
54876 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
54878 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
54879 if(!isWasmInitialized) {
54880 throw new Error("initializeWasm() must be awaited first!");
54882 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
54883 // debug statements here
54885 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54887 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
54888 if(!isWasmInitialized) {
54889 throw new Error("initializeWasm() must be awaited first!");
54891 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
54892 return nativeResponseValue;
54894 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
54896 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
54897 if(!isWasmInitialized) {
54898 throw new Error("initializeWasm() must be awaited first!");
54900 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
54901 // debug statements here
54903 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54905 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
54906 if(!isWasmInitialized) {
54907 throw new Error("initializeWasm() must be awaited first!");
54909 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
54910 return nativeResponseValue;
54912 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
54914 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
54915 if(!isWasmInitialized) {
54916 throw new Error("initializeWasm() must be awaited first!");
54918 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
54919 // debug statements here
54921 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54923 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
54924 if(!isWasmInitialized) {
54925 throw new Error("initializeWasm() must be awaited first!");
54927 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
54928 return nativeResponseValue;
54930 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
54932 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
54933 if(!isWasmInitialized) {
54934 throw new Error("initializeWasm() must be awaited first!");
54936 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
54937 // debug statements here
54939 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54941 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
54942 if(!isWasmInitialized) {
54943 throw new Error("initializeWasm() must be awaited first!");
54945 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
54946 return nativeResponseValue;
54948 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
54950 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
54951 if(!isWasmInitialized) {
54952 throw new Error("initializeWasm() must be awaited first!");
54954 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
54955 // debug statements here
54957 // bool RouteHop_get_maybe_announced_channel(const struct LDKRouteHop *NONNULL_PTR this_ptr);
54959 export function RouteHop_get_maybe_announced_channel(this_ptr: bigint): boolean {
54960 if(!isWasmInitialized) {
54961 throw new Error("initializeWasm() must be awaited first!");
54963 const nativeResponseValue = wasm.TS_RouteHop_get_maybe_announced_channel(this_ptr);
54964 return nativeResponseValue;
54966 // void RouteHop_set_maybe_announced_channel(struct LDKRouteHop *NONNULL_PTR this_ptr, bool val);
54968 export function RouteHop_set_maybe_announced_channel(this_ptr: bigint, val: boolean): void {
54969 if(!isWasmInitialized) {
54970 throw new Error("initializeWasm() must be awaited first!");
54972 const nativeResponseValue = wasm.TS_RouteHop_set_maybe_announced_channel(this_ptr, val);
54973 // debug statements here
54975 // 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, bool maybe_announced_channel_arg);
54977 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, maybe_announced_channel_arg: boolean): bigint {
54978 if(!isWasmInitialized) {
54979 throw new Error("initializeWasm() must be awaited first!");
54981 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, maybe_announced_channel_arg);
54982 return nativeResponseValue;
54984 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
54986 export function RouteHop_clone_ptr(arg: bigint): bigint {
54987 if(!isWasmInitialized) {
54988 throw new Error("initializeWasm() must be awaited first!");
54990 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
54991 return nativeResponseValue;
54993 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
54995 export function RouteHop_clone(orig: bigint): bigint {
54996 if(!isWasmInitialized) {
54997 throw new Error("initializeWasm() must be awaited first!");
54999 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
55000 return nativeResponseValue;
55002 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
55004 export function RouteHop_hash(o: bigint): bigint {
55005 if(!isWasmInitialized) {
55006 throw new Error("initializeWasm() must be awaited first!");
55008 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
55009 return nativeResponseValue;
55011 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
55013 export function RouteHop_eq(a: bigint, b: bigint): boolean {
55014 if(!isWasmInitialized) {
55015 throw new Error("initializeWasm() must be awaited first!");
55017 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
55018 return nativeResponseValue;
55020 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
55022 export function RouteHop_write(obj: bigint): number {
55023 if(!isWasmInitialized) {
55024 throw new Error("initializeWasm() must be awaited first!");
55026 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
55027 return nativeResponseValue;
55029 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
55031 export function RouteHop_read(ser: number): bigint {
55032 if(!isWasmInitialized) {
55033 throw new Error("initializeWasm() must be awaited first!");
55035 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
55036 return nativeResponseValue;
55038 // void BlindedTail_free(struct LDKBlindedTail this_obj);
55040 export function BlindedTail_free(this_obj: bigint): void {
55041 if(!isWasmInitialized) {
55042 throw new Error("initializeWasm() must be awaited first!");
55044 const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
55045 // debug statements here
55047 // struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
55049 export function BlindedTail_get_hops(this_ptr: bigint): number {
55050 if(!isWasmInitialized) {
55051 throw new Error("initializeWasm() must be awaited first!");
55053 const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
55054 return nativeResponseValue;
55056 // void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
55058 export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
55059 if(!isWasmInitialized) {
55060 throw new Error("initializeWasm() must be awaited first!");
55062 const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
55063 // debug statements here
55065 // struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
55067 export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
55068 if(!isWasmInitialized) {
55069 throw new Error("initializeWasm() must be awaited first!");
55071 const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
55072 return nativeResponseValue;
55074 // void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
55076 export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
55077 if(!isWasmInitialized) {
55078 throw new Error("initializeWasm() must be awaited first!");
55080 const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
55081 // debug statements here
55083 // uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
55085 export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
55086 if(!isWasmInitialized) {
55087 throw new Error("initializeWasm() must be awaited first!");
55089 const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
55090 return nativeResponseValue;
55092 // void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
55094 export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
55095 if(!isWasmInitialized) {
55096 throw new Error("initializeWasm() must be awaited first!");
55098 const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
55099 // debug statements here
55101 // uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
55103 export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
55104 if(!isWasmInitialized) {
55105 throw new Error("initializeWasm() must be awaited first!");
55107 const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
55108 return nativeResponseValue;
55110 // void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
55112 export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
55113 if(!isWasmInitialized) {
55114 throw new Error("initializeWasm() must be awaited first!");
55116 const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
55117 // debug statements here
55119 // MUST_USE_RES struct LDKBlindedTail BlindedTail_new(struct LDKCVec_BlindedHopZ hops_arg, struct LDKPublicKey blinding_point_arg, uint32_t excess_final_cltv_expiry_delta_arg, uint64_t final_value_msat_arg);
55121 export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
55122 if(!isWasmInitialized) {
55123 throw new Error("initializeWasm() must be awaited first!");
55125 const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
55126 return nativeResponseValue;
55128 // uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
55130 export function BlindedTail_clone_ptr(arg: bigint): bigint {
55131 if(!isWasmInitialized) {
55132 throw new Error("initializeWasm() must be awaited first!");
55134 const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
55135 return nativeResponseValue;
55137 // struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
55139 export function BlindedTail_clone(orig: bigint): bigint {
55140 if(!isWasmInitialized) {
55141 throw new Error("initializeWasm() must be awaited first!");
55143 const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
55144 return nativeResponseValue;
55146 // uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
55148 export function BlindedTail_hash(o: bigint): bigint {
55149 if(!isWasmInitialized) {
55150 throw new Error("initializeWasm() must be awaited first!");
55152 const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
55153 return nativeResponseValue;
55155 // bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
55157 export function BlindedTail_eq(a: bigint, b: bigint): boolean {
55158 if(!isWasmInitialized) {
55159 throw new Error("initializeWasm() must be awaited first!");
55161 const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
55162 return nativeResponseValue;
55164 // struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
55166 export function BlindedTail_write(obj: bigint): number {
55167 if(!isWasmInitialized) {
55168 throw new Error("initializeWasm() must be awaited first!");
55170 const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
55171 return nativeResponseValue;
55173 // struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
55175 export function BlindedTail_read(ser: number): bigint {
55176 if(!isWasmInitialized) {
55177 throw new Error("initializeWasm() must be awaited first!");
55179 const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
55180 return nativeResponseValue;
55182 // void Path_free(struct LDKPath this_obj);
55184 export function Path_free(this_obj: bigint): void {
55185 if(!isWasmInitialized) {
55186 throw new Error("initializeWasm() must be awaited first!");
55188 const nativeResponseValue = wasm.TS_Path_free(this_obj);
55189 // debug statements here
55191 // struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
55193 export function Path_get_hops(this_ptr: bigint): number {
55194 if(!isWasmInitialized) {
55195 throw new Error("initializeWasm() must be awaited first!");
55197 const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
55198 return nativeResponseValue;
55200 // void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
55202 export function Path_set_hops(this_ptr: bigint, val: number): void {
55203 if(!isWasmInitialized) {
55204 throw new Error("initializeWasm() must be awaited first!");
55206 const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
55207 // debug statements here
55209 // struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
55211 export function Path_get_blinded_tail(this_ptr: bigint): bigint {
55212 if(!isWasmInitialized) {
55213 throw new Error("initializeWasm() must be awaited first!");
55215 const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
55216 return nativeResponseValue;
55218 // void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
55220 export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
55221 if(!isWasmInitialized) {
55222 throw new Error("initializeWasm() must be awaited first!");
55224 const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
55225 // debug statements here
55227 // MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
55229 export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
55230 if(!isWasmInitialized) {
55231 throw new Error("initializeWasm() must be awaited first!");
55233 const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
55234 return nativeResponseValue;
55236 // uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
55238 export function Path_clone_ptr(arg: bigint): bigint {
55239 if(!isWasmInitialized) {
55240 throw new Error("initializeWasm() must be awaited first!");
55242 const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
55243 return nativeResponseValue;
55245 // struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
55247 export function Path_clone(orig: bigint): bigint {
55248 if(!isWasmInitialized) {
55249 throw new Error("initializeWasm() must be awaited first!");
55251 const nativeResponseValue = wasm.TS_Path_clone(orig);
55252 return nativeResponseValue;
55254 // uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
55256 export function Path_hash(o: bigint): bigint {
55257 if(!isWasmInitialized) {
55258 throw new Error("initializeWasm() must be awaited first!");
55260 const nativeResponseValue = wasm.TS_Path_hash(o);
55261 return nativeResponseValue;
55263 // bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
55265 export function Path_eq(a: bigint, b: bigint): boolean {
55266 if(!isWasmInitialized) {
55267 throw new Error("initializeWasm() must be awaited first!");
55269 const nativeResponseValue = wasm.TS_Path_eq(a, b);
55270 return nativeResponseValue;
55272 // MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
55274 export function Path_fee_msat(this_arg: bigint): bigint {
55275 if(!isWasmInitialized) {
55276 throw new Error("initializeWasm() must be awaited first!");
55278 const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
55279 return nativeResponseValue;
55281 // MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
55283 export function Path_final_value_msat(this_arg: bigint): bigint {
55284 if(!isWasmInitialized) {
55285 throw new Error("initializeWasm() must be awaited first!");
55287 const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
55288 return nativeResponseValue;
55290 // MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
55292 export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
55293 if(!isWasmInitialized) {
55294 throw new Error("initializeWasm() must be awaited first!");
55296 const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
55297 return nativeResponseValue;
55299 // void Route_free(struct LDKRoute this_obj);
55301 export function Route_free(this_obj: bigint): void {
55302 if(!isWasmInitialized) {
55303 throw new Error("initializeWasm() must be awaited first!");
55305 const nativeResponseValue = wasm.TS_Route_free(this_obj);
55306 // debug statements here
55308 // struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
55310 export function Route_get_paths(this_ptr: bigint): number {
55311 if(!isWasmInitialized) {
55312 throw new Error("initializeWasm() must be awaited first!");
55314 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
55315 return nativeResponseValue;
55317 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
55319 export function Route_set_paths(this_ptr: bigint, val: number): void {
55320 if(!isWasmInitialized) {
55321 throw new Error("initializeWasm() must be awaited first!");
55323 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
55324 // debug statements here
55326 // struct LDKRouteParameters Route_get_route_params(const struct LDKRoute *NONNULL_PTR this_ptr);
55328 export function Route_get_route_params(this_ptr: bigint): bigint {
55329 if(!isWasmInitialized) {
55330 throw new Error("initializeWasm() must be awaited first!");
55332 const nativeResponseValue = wasm.TS_Route_get_route_params(this_ptr);
55333 return nativeResponseValue;
55335 // void Route_set_route_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKRouteParameters val);
55337 export function Route_set_route_params(this_ptr: bigint, val: bigint): void {
55338 if(!isWasmInitialized) {
55339 throw new Error("initializeWasm() must be awaited first!");
55341 const nativeResponseValue = wasm.TS_Route_set_route_params(this_ptr, val);
55342 // debug statements here
55344 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKRouteParameters route_params_arg);
55346 export function Route_new(paths_arg: number, route_params_arg: bigint): bigint {
55347 if(!isWasmInitialized) {
55348 throw new Error("initializeWasm() must be awaited first!");
55350 const nativeResponseValue = wasm.TS_Route_new(paths_arg, route_params_arg);
55351 return nativeResponseValue;
55353 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
55355 export function Route_clone_ptr(arg: bigint): bigint {
55356 if(!isWasmInitialized) {
55357 throw new Error("initializeWasm() must be awaited first!");
55359 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
55360 return nativeResponseValue;
55362 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
55364 export function Route_clone(orig: bigint): bigint {
55365 if(!isWasmInitialized) {
55366 throw new Error("initializeWasm() must be awaited first!");
55368 const nativeResponseValue = wasm.TS_Route_clone(orig);
55369 return nativeResponseValue;
55371 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
55373 export function Route_hash(o: bigint): bigint {
55374 if(!isWasmInitialized) {
55375 throw new Error("initializeWasm() must be awaited first!");
55377 const nativeResponseValue = wasm.TS_Route_hash(o);
55378 return nativeResponseValue;
55380 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
55382 export function Route_eq(a: bigint, b: bigint): boolean {
55383 if(!isWasmInitialized) {
55384 throw new Error("initializeWasm() must be awaited first!");
55386 const nativeResponseValue = wasm.TS_Route_eq(a, b);
55387 return nativeResponseValue;
55389 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
55391 export function Route_get_total_fees(this_arg: bigint): bigint {
55392 if(!isWasmInitialized) {
55393 throw new Error("initializeWasm() must be awaited first!");
55395 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
55396 return nativeResponseValue;
55398 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
55400 export function Route_get_total_amount(this_arg: bigint): bigint {
55401 if(!isWasmInitialized) {
55402 throw new Error("initializeWasm() must be awaited first!");
55404 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
55405 return nativeResponseValue;
55407 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
55409 export function Route_write(obj: bigint): number {
55410 if(!isWasmInitialized) {
55411 throw new Error("initializeWasm() must be awaited first!");
55413 const nativeResponseValue = wasm.TS_Route_write(obj);
55414 return nativeResponseValue;
55416 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
55418 export function Route_read(ser: number): bigint {
55419 if(!isWasmInitialized) {
55420 throw new Error("initializeWasm() must be awaited first!");
55422 const nativeResponseValue = wasm.TS_Route_read(ser);
55423 return nativeResponseValue;
55425 // void RouteParameters_free(struct LDKRouteParameters this_obj);
55427 export function RouteParameters_free(this_obj: bigint): void {
55428 if(!isWasmInitialized) {
55429 throw new Error("initializeWasm() must be awaited first!");
55431 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
55432 // debug statements here
55434 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
55436 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
55437 if(!isWasmInitialized) {
55438 throw new Error("initializeWasm() must be awaited first!");
55440 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
55441 return nativeResponseValue;
55443 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
55445 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
55446 if(!isWasmInitialized) {
55447 throw new Error("initializeWasm() must be awaited first!");
55449 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
55450 // debug statements here
55452 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
55454 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
55455 if(!isWasmInitialized) {
55456 throw new Error("initializeWasm() must be awaited first!");
55458 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
55459 return nativeResponseValue;
55461 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
55463 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
55464 if(!isWasmInitialized) {
55465 throw new Error("initializeWasm() must be awaited first!");
55467 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
55468 // debug statements here
55470 // struct LDKCOption_u64Z RouteParameters_get_max_total_routing_fee_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
55472 export function RouteParameters_get_max_total_routing_fee_msat(this_ptr: bigint): bigint {
55473 if(!isWasmInitialized) {
55474 throw new Error("initializeWasm() must be awaited first!");
55476 const nativeResponseValue = wasm.TS_RouteParameters_get_max_total_routing_fee_msat(this_ptr);
55477 return nativeResponseValue;
55479 // void RouteParameters_set_max_total_routing_fee_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
55481 export function RouteParameters_set_max_total_routing_fee_msat(this_ptr: bigint, val: bigint): void {
55482 if(!isWasmInitialized) {
55483 throw new Error("initializeWasm() must be awaited first!");
55485 const nativeResponseValue = wasm.TS_RouteParameters_set_max_total_routing_fee_msat(this_ptr, val);
55486 // debug statements here
55488 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg, struct LDKCOption_u64Z max_total_routing_fee_msat_arg);
55490 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, max_total_routing_fee_msat_arg: bigint): bigint {
55491 if(!isWasmInitialized) {
55492 throw new Error("initializeWasm() must be awaited first!");
55494 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, max_total_routing_fee_msat_arg);
55495 return nativeResponseValue;
55497 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
55499 export function RouteParameters_clone_ptr(arg: bigint): bigint {
55500 if(!isWasmInitialized) {
55501 throw new Error("initializeWasm() must be awaited first!");
55503 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
55504 return nativeResponseValue;
55506 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
55508 export function RouteParameters_clone(orig: bigint): bigint {
55509 if(!isWasmInitialized) {
55510 throw new Error("initializeWasm() must be awaited first!");
55512 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
55513 return nativeResponseValue;
55515 // uint64_t RouteParameters_hash(const struct LDKRouteParameters *NONNULL_PTR o);
55517 export function RouteParameters_hash(o: bigint): bigint {
55518 if(!isWasmInitialized) {
55519 throw new Error("initializeWasm() must be awaited first!");
55521 const nativeResponseValue = wasm.TS_RouteParameters_hash(o);
55522 return nativeResponseValue;
55524 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
55526 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
55527 if(!isWasmInitialized) {
55528 throw new Error("initializeWasm() must be awaited first!");
55530 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
55531 return nativeResponseValue;
55533 // MUST_USE_RES struct LDKRouteParameters RouteParameters_from_payment_params_and_value(struct LDKPaymentParameters payment_params, uint64_t final_value_msat);
55535 export function RouteParameters_from_payment_params_and_value(payment_params: bigint, final_value_msat: bigint): bigint {
55536 if(!isWasmInitialized) {
55537 throw new Error("initializeWasm() must be awaited first!");
55539 const nativeResponseValue = wasm.TS_RouteParameters_from_payment_params_and_value(payment_params, final_value_msat);
55540 return nativeResponseValue;
55542 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
55544 export function RouteParameters_write(obj: bigint): number {
55545 if(!isWasmInitialized) {
55546 throw new Error("initializeWasm() must be awaited first!");
55548 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
55549 return nativeResponseValue;
55551 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
55553 export function RouteParameters_read(ser: number): bigint {
55554 if(!isWasmInitialized) {
55555 throw new Error("initializeWasm() must be awaited first!");
55557 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
55558 return nativeResponseValue;
55560 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
55562 export function PaymentParameters_free(this_obj: bigint): void {
55563 if(!isWasmInitialized) {
55564 throw new Error("initializeWasm() must be awaited first!");
55566 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
55567 // debug statements here
55569 // struct LDKPayee PaymentParameters_get_payee(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55571 export function PaymentParameters_get_payee(this_ptr: bigint): bigint {
55572 if(!isWasmInitialized) {
55573 throw new Error("initializeWasm() must be awaited first!");
55575 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee(this_ptr);
55576 return nativeResponseValue;
55578 // void PaymentParameters_set_payee(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
55580 export function PaymentParameters_set_payee(this_ptr: bigint, val: bigint): void {
55581 if(!isWasmInitialized) {
55582 throw new Error("initializeWasm() must be awaited first!");
55584 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee(this_ptr, val);
55585 // debug statements here
55587 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55589 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
55590 if(!isWasmInitialized) {
55591 throw new Error("initializeWasm() must be awaited first!");
55593 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
55594 return nativeResponseValue;
55596 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
55598 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
55599 if(!isWasmInitialized) {
55600 throw new Error("initializeWasm() must be awaited first!");
55602 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
55603 // debug statements here
55605 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55607 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
55608 if(!isWasmInitialized) {
55609 throw new Error("initializeWasm() must be awaited first!");
55611 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
55612 return nativeResponseValue;
55614 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
55616 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
55617 if(!isWasmInitialized) {
55618 throw new Error("initializeWasm() must be awaited first!");
55620 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
55621 // debug statements here
55623 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55625 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
55626 if(!isWasmInitialized) {
55627 throw new Error("initializeWasm() must be awaited first!");
55629 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
55630 return nativeResponseValue;
55632 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
55634 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
55635 if(!isWasmInitialized) {
55636 throw new Error("initializeWasm() must be awaited first!");
55638 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
55639 // debug statements here
55641 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55643 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
55644 if(!isWasmInitialized) {
55645 throw new Error("initializeWasm() must be awaited first!");
55647 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
55648 return nativeResponseValue;
55650 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
55652 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
55653 if(!isWasmInitialized) {
55654 throw new Error("initializeWasm() must be awaited first!");
55656 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
55657 // debug statements here
55659 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55661 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
55662 if(!isWasmInitialized) {
55663 throw new Error("initializeWasm() must be awaited first!");
55665 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
55666 return nativeResponseValue;
55668 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
55670 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
55671 if(!isWasmInitialized) {
55672 throw new Error("initializeWasm() must be awaited first!");
55674 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
55675 // debug statements here
55677 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_blinded_path_idxs(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
55679 export function PaymentParameters_get_previously_failed_blinded_path_idxs(this_ptr: bigint): number {
55680 if(!isWasmInitialized) {
55681 throw new Error("initializeWasm() must be awaited first!");
55683 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_blinded_path_idxs(this_ptr);
55684 return nativeResponseValue;
55686 // void PaymentParameters_set_previously_failed_blinded_path_idxs(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
55688 export function PaymentParameters_set_previously_failed_blinded_path_idxs(this_ptr: bigint, val: number): void {
55689 if(!isWasmInitialized) {
55690 throw new Error("initializeWasm() must be awaited first!");
55692 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_blinded_path_idxs(this_ptr, val);
55693 // debug statements here
55695 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPayee payee_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, struct LDKCVec_u64Z previously_failed_blinded_path_idxs_arg);
55697 export function PaymentParameters_new(payee_arg: bigint, 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, previously_failed_blinded_path_idxs_arg: number): bigint {
55698 if(!isWasmInitialized) {
55699 throw new Error("initializeWasm() must be awaited first!");
55701 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_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, previously_failed_blinded_path_idxs_arg);
55702 return nativeResponseValue;
55704 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
55706 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
55707 if(!isWasmInitialized) {
55708 throw new Error("initializeWasm() must be awaited first!");
55710 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
55711 return nativeResponseValue;
55713 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
55715 export function PaymentParameters_clone(orig: bigint): bigint {
55716 if(!isWasmInitialized) {
55717 throw new Error("initializeWasm() must be awaited first!");
55719 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
55720 return nativeResponseValue;
55722 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
55724 export function PaymentParameters_hash(o: bigint): bigint {
55725 if(!isWasmInitialized) {
55726 throw new Error("initializeWasm() must be awaited first!");
55728 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
55729 return nativeResponseValue;
55731 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
55733 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
55734 if(!isWasmInitialized) {
55735 throw new Error("initializeWasm() must be awaited first!");
55737 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
55738 return nativeResponseValue;
55740 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
55742 export function PaymentParameters_write(obj: bigint): number {
55743 if(!isWasmInitialized) {
55744 throw new Error("initializeWasm() must be awaited first!");
55746 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
55747 return nativeResponseValue;
55749 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
55751 export function PaymentParameters_read(ser: number, arg: number): bigint {
55752 if(!isWasmInitialized) {
55753 throw new Error("initializeWasm() must be awaited first!");
55755 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
55756 return nativeResponseValue;
55758 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
55760 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
55761 if(!isWasmInitialized) {
55762 throw new Error("initializeWasm() must be awaited first!");
55764 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
55765 return nativeResponseValue;
55767 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta, bool allow_mpp);
55769 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number, allow_mpp: boolean): bigint {
55770 if(!isWasmInitialized) {
55771 throw new Error("initializeWasm() must be awaited first!");
55773 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta, allow_mpp);
55774 return nativeResponseValue;
55776 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_bolt12_invoice(const struct LDKBolt12Invoice *NONNULL_PTR invoice);
55778 export function PaymentParameters_from_bolt12_invoice(invoice: bigint): bigint {
55779 if(!isWasmInitialized) {
55780 throw new Error("initializeWasm() must be awaited first!");
55782 const nativeResponseValue = wasm.TS_PaymentParameters_from_bolt12_invoice(invoice);
55783 return nativeResponseValue;
55785 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_route_hints);
55787 export function PaymentParameters_blinded(blinded_route_hints: number): bigint {
55788 if(!isWasmInitialized) {
55789 throw new Error("initializeWasm() must be awaited first!");
55791 const nativeResponseValue = wasm.TS_PaymentParameters_blinded(blinded_route_hints);
55792 return nativeResponseValue;
55794 // void Payee_free(struct LDKPayee this_ptr);
55796 export function Payee_free(this_ptr: bigint): void {
55797 if(!isWasmInitialized) {
55798 throw new Error("initializeWasm() must be awaited first!");
55800 const nativeResponseValue = wasm.TS_Payee_free(this_ptr);
55801 // debug statements here
55803 // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
55805 export function Payee_clone_ptr(arg: bigint): bigint {
55806 if(!isWasmInitialized) {
55807 throw new Error("initializeWasm() must be awaited first!");
55809 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
55810 return nativeResponseValue;
55812 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
55814 export function Payee_clone(orig: bigint): bigint {
55815 if(!isWasmInitialized) {
55816 throw new Error("initializeWasm() must be awaited first!");
55818 const nativeResponseValue = wasm.TS_Payee_clone(orig);
55819 return nativeResponseValue;
55821 // struct LDKPayee Payee_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints, struct LDKBolt12InvoiceFeatures features);
55823 export function Payee_blinded(route_hints: number, features: bigint): bigint {
55824 if(!isWasmInitialized) {
55825 throw new Error("initializeWasm() must be awaited first!");
55827 const nativeResponseValue = wasm.TS_Payee_blinded(route_hints, features);
55828 return nativeResponseValue;
55830 // struct LDKPayee Payee_clear(struct LDKPublicKey node_id, struct LDKCVec_RouteHintZ route_hints, struct LDKBolt11InvoiceFeatures features, uint32_t final_cltv_expiry_delta);
55832 export function Payee_clear(node_id: number, route_hints: number, features: bigint, final_cltv_expiry_delta: number): bigint {
55833 if(!isWasmInitialized) {
55834 throw new Error("initializeWasm() must be awaited first!");
55836 const nativeResponseValue = wasm.TS_Payee_clear(node_id, route_hints, features, final_cltv_expiry_delta);
55837 return nativeResponseValue;
55839 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
55841 export function Payee_hash(o: bigint): bigint {
55842 if(!isWasmInitialized) {
55843 throw new Error("initializeWasm() must be awaited first!");
55845 const nativeResponseValue = wasm.TS_Payee_hash(o);
55846 return nativeResponseValue;
55848 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
55850 export function Payee_eq(a: bigint, b: bigint): boolean {
55851 if(!isWasmInitialized) {
55852 throw new Error("initializeWasm() must be awaited first!");
55854 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
55855 return nativeResponseValue;
55857 // void RouteHint_free(struct LDKRouteHint this_obj);
55859 export function RouteHint_free(this_obj: bigint): void {
55860 if(!isWasmInitialized) {
55861 throw new Error("initializeWasm() must be awaited first!");
55863 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
55864 // debug statements here
55866 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
55868 export function RouteHint_get_a(this_ptr: bigint): number {
55869 if(!isWasmInitialized) {
55870 throw new Error("initializeWasm() must be awaited first!");
55872 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
55873 return nativeResponseValue;
55875 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
55877 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
55878 if(!isWasmInitialized) {
55879 throw new Error("initializeWasm() must be awaited first!");
55881 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
55882 // debug statements here
55884 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
55886 export function RouteHint_new(a_arg: number): bigint {
55887 if(!isWasmInitialized) {
55888 throw new Error("initializeWasm() must be awaited first!");
55890 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
55891 return nativeResponseValue;
55893 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
55895 export function RouteHint_clone_ptr(arg: bigint): bigint {
55896 if(!isWasmInitialized) {
55897 throw new Error("initializeWasm() must be awaited first!");
55899 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
55900 return nativeResponseValue;
55902 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
55904 export function RouteHint_clone(orig: bigint): bigint {
55905 if(!isWasmInitialized) {
55906 throw new Error("initializeWasm() must be awaited first!");
55908 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
55909 return nativeResponseValue;
55911 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
55913 export function RouteHint_hash(o: bigint): bigint {
55914 if(!isWasmInitialized) {
55915 throw new Error("initializeWasm() must be awaited first!");
55917 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
55918 return nativeResponseValue;
55920 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
55922 export function RouteHint_eq(a: bigint, b: bigint): boolean {
55923 if(!isWasmInitialized) {
55924 throw new Error("initializeWasm() must be awaited first!");
55926 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
55927 return nativeResponseValue;
55929 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
55931 export function RouteHint_write(obj: bigint): number {
55932 if(!isWasmInitialized) {
55933 throw new Error("initializeWasm() must be awaited first!");
55935 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
55936 return nativeResponseValue;
55938 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
55940 export function RouteHint_read(ser: number): bigint {
55941 if(!isWasmInitialized) {
55942 throw new Error("initializeWasm() must be awaited first!");
55944 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
55945 return nativeResponseValue;
55947 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
55949 export function RouteHintHop_free(this_obj: bigint): void {
55950 if(!isWasmInitialized) {
55951 throw new Error("initializeWasm() must be awaited first!");
55953 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
55954 // debug statements here
55956 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
55958 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
55959 if(!isWasmInitialized) {
55960 throw new Error("initializeWasm() must be awaited first!");
55962 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
55963 return nativeResponseValue;
55965 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
55967 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
55968 if(!isWasmInitialized) {
55969 throw new Error("initializeWasm() must be awaited first!");
55971 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
55972 // debug statements here
55974 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
55976 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
55977 if(!isWasmInitialized) {
55978 throw new Error("initializeWasm() must be awaited first!");
55980 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
55981 return nativeResponseValue;
55983 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
55985 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
55986 if(!isWasmInitialized) {
55987 throw new Error("initializeWasm() must be awaited first!");
55989 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
55990 // debug statements here
55992 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
55994 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
55995 if(!isWasmInitialized) {
55996 throw new Error("initializeWasm() must be awaited first!");
55998 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
55999 return nativeResponseValue;
56001 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
56003 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
56004 if(!isWasmInitialized) {
56005 throw new Error("initializeWasm() must be awaited first!");
56007 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
56008 // debug statements here
56010 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
56012 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
56013 if(!isWasmInitialized) {
56014 throw new Error("initializeWasm() must be awaited first!");
56016 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
56017 return nativeResponseValue;
56019 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
56021 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
56022 if(!isWasmInitialized) {
56023 throw new Error("initializeWasm() must be awaited first!");
56025 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
56026 // debug statements here
56028 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
56030 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
56031 if(!isWasmInitialized) {
56032 throw new Error("initializeWasm() must be awaited first!");
56034 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
56035 return nativeResponseValue;
56037 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
56039 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
56040 if(!isWasmInitialized) {
56041 throw new Error("initializeWasm() must be awaited first!");
56043 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
56044 // debug statements here
56046 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
56048 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
56049 if(!isWasmInitialized) {
56050 throw new Error("initializeWasm() must be awaited first!");
56052 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
56053 return nativeResponseValue;
56055 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
56057 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
56058 if(!isWasmInitialized) {
56059 throw new Error("initializeWasm() must be awaited first!");
56061 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
56062 // debug statements here
56064 // 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);
56066 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 {
56067 if(!isWasmInitialized) {
56068 throw new Error("initializeWasm() must be awaited first!");
56070 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);
56071 return nativeResponseValue;
56073 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
56075 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
56076 if(!isWasmInitialized) {
56077 throw new Error("initializeWasm() must be awaited first!");
56079 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
56080 return nativeResponseValue;
56082 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
56084 export function RouteHintHop_clone(orig: bigint): bigint {
56085 if(!isWasmInitialized) {
56086 throw new Error("initializeWasm() must be awaited first!");
56088 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
56089 return nativeResponseValue;
56091 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
56093 export function RouteHintHop_hash(o: bigint): bigint {
56094 if(!isWasmInitialized) {
56095 throw new Error("initializeWasm() must be awaited first!");
56097 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
56098 return nativeResponseValue;
56100 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
56102 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
56103 if(!isWasmInitialized) {
56104 throw new Error("initializeWasm() must be awaited first!");
56106 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
56107 return nativeResponseValue;
56109 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
56111 export function RouteHintHop_write(obj: bigint): number {
56112 if(!isWasmInitialized) {
56113 throw new Error("initializeWasm() must be awaited first!");
56115 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
56116 return nativeResponseValue;
56118 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
56120 export function RouteHintHop_read(ser: number): bigint {
56121 if(!isWasmInitialized) {
56122 throw new Error("initializeWasm() must be awaited first!");
56124 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
56125 return nativeResponseValue;
56127 // void FirstHopCandidate_free(struct LDKFirstHopCandidate this_obj);
56129 export function FirstHopCandidate_free(this_obj: bigint): void {
56130 if(!isWasmInitialized) {
56131 throw new Error("initializeWasm() must be awaited first!");
56133 const nativeResponseValue = wasm.TS_FirstHopCandidate_free(this_obj);
56134 // debug statements here
56136 // uint64_t FirstHopCandidate_clone_ptr(LDKFirstHopCandidate *NONNULL_PTR arg);
56138 export function FirstHopCandidate_clone_ptr(arg: bigint): bigint {
56139 if(!isWasmInitialized) {
56140 throw new Error("initializeWasm() must be awaited first!");
56142 const nativeResponseValue = wasm.TS_FirstHopCandidate_clone_ptr(arg);
56143 return nativeResponseValue;
56145 // struct LDKFirstHopCandidate FirstHopCandidate_clone(const struct LDKFirstHopCandidate *NONNULL_PTR orig);
56147 export function FirstHopCandidate_clone(orig: bigint): bigint {
56148 if(!isWasmInitialized) {
56149 throw new Error("initializeWasm() must be awaited first!");
56151 const nativeResponseValue = wasm.TS_FirstHopCandidate_clone(orig);
56152 return nativeResponseValue;
56154 // void PublicHopCandidate_free(struct LDKPublicHopCandidate this_obj);
56156 export function PublicHopCandidate_free(this_obj: bigint): void {
56157 if(!isWasmInitialized) {
56158 throw new Error("initializeWasm() must be awaited first!");
56160 const nativeResponseValue = wasm.TS_PublicHopCandidate_free(this_obj);
56161 // debug statements here
56163 // uint64_t PublicHopCandidate_get_short_channel_id(const struct LDKPublicHopCandidate *NONNULL_PTR this_ptr);
56165 export function PublicHopCandidate_get_short_channel_id(this_ptr: bigint): bigint {
56166 if(!isWasmInitialized) {
56167 throw new Error("initializeWasm() must be awaited first!");
56169 const nativeResponseValue = wasm.TS_PublicHopCandidate_get_short_channel_id(this_ptr);
56170 return nativeResponseValue;
56172 // void PublicHopCandidate_set_short_channel_id(struct LDKPublicHopCandidate *NONNULL_PTR this_ptr, uint64_t val);
56174 export function PublicHopCandidate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
56175 if(!isWasmInitialized) {
56176 throw new Error("initializeWasm() must be awaited first!");
56178 const nativeResponseValue = wasm.TS_PublicHopCandidate_set_short_channel_id(this_ptr, val);
56179 // debug statements here
56181 // uint64_t PublicHopCandidate_clone_ptr(LDKPublicHopCandidate *NONNULL_PTR arg);
56183 export function PublicHopCandidate_clone_ptr(arg: bigint): bigint {
56184 if(!isWasmInitialized) {
56185 throw new Error("initializeWasm() must be awaited first!");
56187 const nativeResponseValue = wasm.TS_PublicHopCandidate_clone_ptr(arg);
56188 return nativeResponseValue;
56190 // struct LDKPublicHopCandidate PublicHopCandidate_clone(const struct LDKPublicHopCandidate *NONNULL_PTR orig);
56192 export function PublicHopCandidate_clone(orig: bigint): bigint {
56193 if(!isWasmInitialized) {
56194 throw new Error("initializeWasm() must be awaited first!");
56196 const nativeResponseValue = wasm.TS_PublicHopCandidate_clone(orig);
56197 return nativeResponseValue;
56199 // void PrivateHopCandidate_free(struct LDKPrivateHopCandidate this_obj);
56201 export function PrivateHopCandidate_free(this_obj: bigint): void {
56202 if(!isWasmInitialized) {
56203 throw new Error("initializeWasm() must be awaited first!");
56205 const nativeResponseValue = wasm.TS_PrivateHopCandidate_free(this_obj);
56206 // debug statements here
56208 // uint64_t PrivateHopCandidate_clone_ptr(LDKPrivateHopCandidate *NONNULL_PTR arg);
56210 export function PrivateHopCandidate_clone_ptr(arg: bigint): bigint {
56211 if(!isWasmInitialized) {
56212 throw new Error("initializeWasm() must be awaited first!");
56214 const nativeResponseValue = wasm.TS_PrivateHopCandidate_clone_ptr(arg);
56215 return nativeResponseValue;
56217 // struct LDKPrivateHopCandidate PrivateHopCandidate_clone(const struct LDKPrivateHopCandidate *NONNULL_PTR orig);
56219 export function PrivateHopCandidate_clone(orig: bigint): bigint {
56220 if(!isWasmInitialized) {
56221 throw new Error("initializeWasm() must be awaited first!");
56223 const nativeResponseValue = wasm.TS_PrivateHopCandidate_clone(orig);
56224 return nativeResponseValue;
56226 // void BlindedPathCandidate_free(struct LDKBlindedPathCandidate this_obj);
56228 export function BlindedPathCandidate_free(this_obj: bigint): void {
56229 if(!isWasmInitialized) {
56230 throw new Error("initializeWasm() must be awaited first!");
56232 const nativeResponseValue = wasm.TS_BlindedPathCandidate_free(this_obj);
56233 // debug statements here
56235 // uint64_t BlindedPathCandidate_clone_ptr(LDKBlindedPathCandidate *NONNULL_PTR arg);
56237 export function BlindedPathCandidate_clone_ptr(arg: bigint): bigint {
56238 if(!isWasmInitialized) {
56239 throw new Error("initializeWasm() must be awaited first!");
56241 const nativeResponseValue = wasm.TS_BlindedPathCandidate_clone_ptr(arg);
56242 return nativeResponseValue;
56244 // struct LDKBlindedPathCandidate BlindedPathCandidate_clone(const struct LDKBlindedPathCandidate *NONNULL_PTR orig);
56246 export function BlindedPathCandidate_clone(orig: bigint): bigint {
56247 if(!isWasmInitialized) {
56248 throw new Error("initializeWasm() must be awaited first!");
56250 const nativeResponseValue = wasm.TS_BlindedPathCandidate_clone(orig);
56251 return nativeResponseValue;
56253 // void OneHopBlindedPathCandidate_free(struct LDKOneHopBlindedPathCandidate this_obj);
56255 export function OneHopBlindedPathCandidate_free(this_obj: bigint): void {
56256 if(!isWasmInitialized) {
56257 throw new Error("initializeWasm() must be awaited first!");
56259 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_free(this_obj);
56260 // debug statements here
56262 // uint64_t OneHopBlindedPathCandidate_clone_ptr(LDKOneHopBlindedPathCandidate *NONNULL_PTR arg);
56264 export function OneHopBlindedPathCandidate_clone_ptr(arg: bigint): bigint {
56265 if(!isWasmInitialized) {
56266 throw new Error("initializeWasm() must be awaited first!");
56268 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_clone_ptr(arg);
56269 return nativeResponseValue;
56271 // struct LDKOneHopBlindedPathCandidate OneHopBlindedPathCandidate_clone(const struct LDKOneHopBlindedPathCandidate *NONNULL_PTR orig);
56273 export function OneHopBlindedPathCandidate_clone(orig: bigint): bigint {
56274 if(!isWasmInitialized) {
56275 throw new Error("initializeWasm() must be awaited first!");
56277 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_clone(orig);
56278 return nativeResponseValue;
56280 // void CandidateRouteHop_free(struct LDKCandidateRouteHop this_ptr);
56282 export function CandidateRouteHop_free(this_ptr: bigint): void {
56283 if(!isWasmInitialized) {
56284 throw new Error("initializeWasm() must be awaited first!");
56286 const nativeResponseValue = wasm.TS_CandidateRouteHop_free(this_ptr);
56287 // debug statements here
56289 // uint64_t CandidateRouteHop_clone_ptr(LDKCandidateRouteHop *NONNULL_PTR arg);
56291 export function CandidateRouteHop_clone_ptr(arg: bigint): bigint {
56292 if(!isWasmInitialized) {
56293 throw new Error("initializeWasm() must be awaited first!");
56295 const nativeResponseValue = wasm.TS_CandidateRouteHop_clone_ptr(arg);
56296 return nativeResponseValue;
56298 // struct LDKCandidateRouteHop CandidateRouteHop_clone(const struct LDKCandidateRouteHop *NONNULL_PTR orig);
56300 export function CandidateRouteHop_clone(orig: bigint): bigint {
56301 if(!isWasmInitialized) {
56302 throw new Error("initializeWasm() must be awaited first!");
56304 const nativeResponseValue = wasm.TS_CandidateRouteHop_clone(orig);
56305 return nativeResponseValue;
56307 // struct LDKCandidateRouteHop CandidateRouteHop_first_hop(struct LDKFirstHopCandidate a);
56309 export function CandidateRouteHop_first_hop(a: bigint): bigint {
56310 if(!isWasmInitialized) {
56311 throw new Error("initializeWasm() must be awaited first!");
56313 const nativeResponseValue = wasm.TS_CandidateRouteHop_first_hop(a);
56314 return nativeResponseValue;
56316 // struct LDKCandidateRouteHop CandidateRouteHop_public_hop(struct LDKPublicHopCandidate a);
56318 export function CandidateRouteHop_public_hop(a: bigint): bigint {
56319 if(!isWasmInitialized) {
56320 throw new Error("initializeWasm() must be awaited first!");
56322 const nativeResponseValue = wasm.TS_CandidateRouteHop_public_hop(a);
56323 return nativeResponseValue;
56325 // struct LDKCandidateRouteHop CandidateRouteHop_private_hop(struct LDKPrivateHopCandidate a);
56327 export function CandidateRouteHop_private_hop(a: bigint): bigint {
56328 if(!isWasmInitialized) {
56329 throw new Error("initializeWasm() must be awaited first!");
56331 const nativeResponseValue = wasm.TS_CandidateRouteHop_private_hop(a);
56332 return nativeResponseValue;
56334 // struct LDKCandidateRouteHop CandidateRouteHop_blinded(struct LDKBlindedPathCandidate a);
56336 export function CandidateRouteHop_blinded(a: bigint): bigint {
56337 if(!isWasmInitialized) {
56338 throw new Error("initializeWasm() must be awaited first!");
56340 const nativeResponseValue = wasm.TS_CandidateRouteHop_blinded(a);
56341 return nativeResponseValue;
56343 // struct LDKCandidateRouteHop CandidateRouteHop_one_hop_blinded(struct LDKOneHopBlindedPathCandidate a);
56345 export function CandidateRouteHop_one_hop_blinded(a: bigint): bigint {
56346 if(!isWasmInitialized) {
56347 throw new Error("initializeWasm() must be awaited first!");
56349 const nativeResponseValue = wasm.TS_CandidateRouteHop_one_hop_blinded(a);
56350 return nativeResponseValue;
56352 // MUST_USE_RES struct LDKCOption_u64Z CandidateRouteHop_globally_unique_short_channel_id(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56354 export function CandidateRouteHop_globally_unique_short_channel_id(this_arg: bigint): bigint {
56355 if(!isWasmInitialized) {
56356 throw new Error("initializeWasm() must be awaited first!");
56358 const nativeResponseValue = wasm.TS_CandidateRouteHop_globally_unique_short_channel_id(this_arg);
56359 return nativeResponseValue;
56361 // MUST_USE_RES uint32_t CandidateRouteHop_cltv_expiry_delta(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56363 export function CandidateRouteHop_cltv_expiry_delta(this_arg: bigint): number {
56364 if(!isWasmInitialized) {
56365 throw new Error("initializeWasm() must be awaited first!");
56367 const nativeResponseValue = wasm.TS_CandidateRouteHop_cltv_expiry_delta(this_arg);
56368 return nativeResponseValue;
56370 // MUST_USE_RES uint64_t CandidateRouteHop_htlc_minimum_msat(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56372 export function CandidateRouteHop_htlc_minimum_msat(this_arg: bigint): bigint {
56373 if(!isWasmInitialized) {
56374 throw new Error("initializeWasm() must be awaited first!");
56376 const nativeResponseValue = wasm.TS_CandidateRouteHop_htlc_minimum_msat(this_arg);
56377 return nativeResponseValue;
56379 // MUST_USE_RES struct LDKRoutingFees CandidateRouteHop_fees(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56381 export function CandidateRouteHop_fees(this_arg: bigint): bigint {
56382 if(!isWasmInitialized) {
56383 throw new Error("initializeWasm() must be awaited first!");
56385 const nativeResponseValue = wasm.TS_CandidateRouteHop_fees(this_arg);
56386 return nativeResponseValue;
56388 // MUST_USE_RES struct LDKNodeId CandidateRouteHop_source(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56390 export function CandidateRouteHop_source(this_arg: bigint): bigint {
56391 if(!isWasmInitialized) {
56392 throw new Error("initializeWasm() must be awaited first!");
56394 const nativeResponseValue = wasm.TS_CandidateRouteHop_source(this_arg);
56395 return nativeResponseValue;
56397 // MUST_USE_RES struct LDKNodeId CandidateRouteHop_target(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
56399 export function CandidateRouteHop_target(this_arg: bigint): bigint {
56400 if(!isWasmInitialized) {
56401 throw new Error("initializeWasm() must be awaited first!");
56403 const nativeResponseValue = wasm.TS_CandidateRouteHop_target(this_arg);
56404 return nativeResponseValue;
56406 // 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 LDKScoreLookUp *NONNULL_PTR scorer, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params, const uint8_t (*random_seed_bytes)[32]);
56408 export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, score_params: bigint, random_seed_bytes: number): bigint {
56409 if(!isWasmInitialized) {
56410 throw new Error("initializeWasm() must be awaited first!");
56412 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, score_params, random_seed_bytes);
56413 return nativeResponseValue;
56415 // 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]);
56417 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 {
56418 if(!isWasmInitialized) {
56419 throw new Error("initializeWasm() must be awaited first!");
56421 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
56422 return nativeResponseValue;
56424 // void ScoreLookUp_free(struct LDKScoreLookUp this_ptr);
56426 export function ScoreLookUp_free(this_ptr: bigint): void {
56427 if(!isWasmInitialized) {
56428 throw new Error("initializeWasm() must be awaited first!");
56430 const nativeResponseValue = wasm.TS_ScoreLookUp_free(this_ptr);
56431 // debug statements here
56433 // void ScoreUpdate_free(struct LDKScoreUpdate this_ptr);
56435 export function ScoreUpdate_free(this_ptr: bigint): void {
56436 if(!isWasmInitialized) {
56437 throw new Error("initializeWasm() must be awaited first!");
56439 const nativeResponseValue = wasm.TS_ScoreUpdate_free(this_ptr);
56440 // debug statements here
56442 // void Score_free(struct LDKScore this_ptr);
56444 export function Score_free(this_ptr: bigint): void {
56445 if(!isWasmInitialized) {
56446 throw new Error("initializeWasm() must be awaited first!");
56448 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
56449 // debug statements here
56451 // void LockableScore_free(struct LDKLockableScore this_ptr);
56453 export function LockableScore_free(this_ptr: bigint): void {
56454 if(!isWasmInitialized) {
56455 throw new Error("initializeWasm() must be awaited first!");
56457 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
56458 // debug statements here
56460 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
56462 export function WriteableScore_free(this_ptr: bigint): void {
56463 if(!isWasmInitialized) {
56464 throw new Error("initializeWasm() must be awaited first!");
56466 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
56467 // debug statements here
56469 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
56471 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
56472 if(!isWasmInitialized) {
56473 throw new Error("initializeWasm() must be awaited first!");
56475 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
56476 // debug statements here
56478 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
56480 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
56481 if(!isWasmInitialized) {
56482 throw new Error("initializeWasm() must be awaited first!");
56484 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
56485 return nativeResponseValue;
56487 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
56489 export function MultiThreadedLockableScore_write(obj: bigint): number {
56490 if(!isWasmInitialized) {
56491 throw new Error("initializeWasm() must be awaited first!");
56493 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
56494 return nativeResponseValue;
56496 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
56498 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
56499 if(!isWasmInitialized) {
56500 throw new Error("initializeWasm() must be awaited first!");
56502 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
56503 return nativeResponseValue;
56505 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
56507 export function MultiThreadedLockableScore_new(score: bigint): bigint {
56508 if(!isWasmInitialized) {
56509 throw new Error("initializeWasm() must be awaited first!");
56511 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
56512 return nativeResponseValue;
56514 // void MultiThreadedScoreLockRead_free(struct LDKMultiThreadedScoreLockRead this_obj);
56516 export function MultiThreadedScoreLockRead_free(this_obj: bigint): void {
56517 if(!isWasmInitialized) {
56518 throw new Error("initializeWasm() must be awaited first!");
56520 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_free(this_obj);
56521 // debug statements here
56523 // void MultiThreadedScoreLockWrite_free(struct LDKMultiThreadedScoreLockWrite this_obj);
56525 export function MultiThreadedScoreLockWrite_free(this_obj: bigint): void {
56526 if(!isWasmInitialized) {
56527 throw new Error("initializeWasm() must be awaited first!");
56529 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_free(this_obj);
56530 // debug statements here
56532 // struct LDKScoreLookUp MultiThreadedScoreLockRead_as_ScoreLookUp(const struct LDKMultiThreadedScoreLockRead *NONNULL_PTR this_arg);
56534 export function MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg: bigint): bigint {
56535 if(!isWasmInitialized) {
56536 throw new Error("initializeWasm() must be awaited first!");
56538 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg);
56539 return nativeResponseValue;
56541 // struct LDKCVec_u8Z MultiThreadedScoreLockWrite_write(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR obj);
56543 export function MultiThreadedScoreLockWrite_write(obj: bigint): number {
56544 if(!isWasmInitialized) {
56545 throw new Error("initializeWasm() must be awaited first!");
56547 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_write(obj);
56548 return nativeResponseValue;
56550 // struct LDKScoreUpdate MultiThreadedScoreLockWrite_as_ScoreUpdate(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR this_arg);
56552 export function MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg: bigint): bigint {
56553 if(!isWasmInitialized) {
56554 throw new Error("initializeWasm() must be awaited first!");
56556 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg);
56557 return nativeResponseValue;
56559 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
56561 export function ChannelUsage_free(this_obj: bigint): void {
56562 if(!isWasmInitialized) {
56563 throw new Error("initializeWasm() must be awaited first!");
56565 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
56566 // debug statements here
56568 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
56570 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
56571 if(!isWasmInitialized) {
56572 throw new Error("initializeWasm() must be awaited first!");
56574 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
56575 return nativeResponseValue;
56577 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
56579 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
56580 if(!isWasmInitialized) {
56581 throw new Error("initializeWasm() must be awaited first!");
56583 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
56584 // debug statements here
56586 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
56588 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
56589 if(!isWasmInitialized) {
56590 throw new Error("initializeWasm() must be awaited first!");
56592 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
56593 return nativeResponseValue;
56595 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
56597 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
56598 if(!isWasmInitialized) {
56599 throw new Error("initializeWasm() must be awaited first!");
56601 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
56602 // debug statements here
56604 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
56606 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
56607 if(!isWasmInitialized) {
56608 throw new Error("initializeWasm() must be awaited first!");
56610 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
56611 return nativeResponseValue;
56613 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
56615 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
56616 if(!isWasmInitialized) {
56617 throw new Error("initializeWasm() must be awaited first!");
56619 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
56620 // debug statements here
56622 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
56624 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
56625 if(!isWasmInitialized) {
56626 throw new Error("initializeWasm() must be awaited first!");
56628 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
56629 return nativeResponseValue;
56631 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
56633 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
56634 if(!isWasmInitialized) {
56635 throw new Error("initializeWasm() must be awaited first!");
56637 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
56638 return nativeResponseValue;
56640 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
56642 export function ChannelUsage_clone(orig: bigint): bigint {
56643 if(!isWasmInitialized) {
56644 throw new Error("initializeWasm() must be awaited first!");
56646 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
56647 return nativeResponseValue;
56649 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
56651 export function FixedPenaltyScorer_free(this_obj: bigint): void {
56652 if(!isWasmInitialized) {
56653 throw new Error("initializeWasm() must be awaited first!");
56655 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
56656 // debug statements here
56658 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
56660 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
56661 if(!isWasmInitialized) {
56662 throw new Error("initializeWasm() must be awaited first!");
56664 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
56665 return nativeResponseValue;
56667 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
56669 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
56670 if(!isWasmInitialized) {
56671 throw new Error("initializeWasm() must be awaited first!");
56673 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
56674 return nativeResponseValue;
56676 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
56678 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
56679 if(!isWasmInitialized) {
56680 throw new Error("initializeWasm() must be awaited first!");
56682 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
56683 return nativeResponseValue;
56685 // struct LDKScoreLookUp FixedPenaltyScorer_as_ScoreLookUp(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
56687 export function FixedPenaltyScorer_as_ScoreLookUp(this_arg: bigint): bigint {
56688 if(!isWasmInitialized) {
56689 throw new Error("initializeWasm() must be awaited first!");
56691 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreLookUp(this_arg);
56692 return nativeResponseValue;
56694 // struct LDKScoreUpdate FixedPenaltyScorer_as_ScoreUpdate(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
56696 export function FixedPenaltyScorer_as_ScoreUpdate(this_arg: bigint): bigint {
56697 if(!isWasmInitialized) {
56698 throw new Error("initializeWasm() must be awaited first!");
56700 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreUpdate(this_arg);
56701 return nativeResponseValue;
56703 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
56705 export function FixedPenaltyScorer_write(obj: bigint): number {
56706 if(!isWasmInitialized) {
56707 throw new Error("initializeWasm() must be awaited first!");
56709 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
56710 return nativeResponseValue;
56712 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
56714 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
56715 if(!isWasmInitialized) {
56716 throw new Error("initializeWasm() must be awaited first!");
56718 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
56719 return nativeResponseValue;
56721 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
56723 export function ProbabilisticScorer_free(this_obj: bigint): void {
56724 if(!isWasmInitialized) {
56725 throw new Error("initializeWasm() must be awaited first!");
56727 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
56728 // debug statements here
56730 // void ProbabilisticScoringFeeParameters_free(struct LDKProbabilisticScoringFeeParameters this_obj);
56732 export function ProbabilisticScoringFeeParameters_free(this_obj: bigint): void {
56733 if(!isWasmInitialized) {
56734 throw new Error("initializeWasm() must be awaited first!");
56736 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_free(this_obj);
56737 // debug statements here
56739 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56741 export function ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
56742 if(!isWasmInitialized) {
56743 throw new Error("initializeWasm() must be awaited first!");
56745 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr);
56746 return nativeResponseValue;
56748 // void ProbabilisticScoringFeeParameters_set_base_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56750 export function ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
56751 if(!isWasmInitialized) {
56752 throw new Error("initializeWasm() must be awaited first!");
56754 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr, val);
56755 // debug statements here
56757 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56759 export function ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
56760 if(!isWasmInitialized) {
56761 throw new Error("initializeWasm() must be awaited first!");
56763 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
56764 return nativeResponseValue;
56766 // void ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56768 export function ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
56769 if(!isWasmInitialized) {
56770 throw new Error("initializeWasm() must be awaited first!");
56772 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
56773 // debug statements here
56775 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56777 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
56778 if(!isWasmInitialized) {
56779 throw new Error("initializeWasm() must be awaited first!");
56781 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
56782 return nativeResponseValue;
56784 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56786 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
56787 if(!isWasmInitialized) {
56788 throw new Error("initializeWasm() must be awaited first!");
56790 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
56791 // debug statements here
56793 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56795 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
56796 if(!isWasmInitialized) {
56797 throw new Error("initializeWasm() must be awaited first!");
56799 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
56800 return nativeResponseValue;
56802 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56804 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
56805 if(!isWasmInitialized) {
56806 throw new Error("initializeWasm() must be awaited first!");
56808 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
56809 // debug statements here
56811 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56813 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
56814 if(!isWasmInitialized) {
56815 throw new Error("initializeWasm() must be awaited first!");
56817 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
56818 return nativeResponseValue;
56820 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56822 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
56823 if(!isWasmInitialized) {
56824 throw new Error("initializeWasm() must be awaited first!");
56826 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
56827 // debug statements here
56829 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56831 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
56832 if(!isWasmInitialized) {
56833 throw new Error("initializeWasm() must be awaited first!");
56835 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
56836 return nativeResponseValue;
56838 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56840 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
56841 if(!isWasmInitialized) {
56842 throw new Error("initializeWasm() must be awaited first!");
56844 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
56845 // debug statements here
56847 // uint64_t ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56849 export function ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
56850 if(!isWasmInitialized) {
56851 throw new Error("initializeWasm() must be awaited first!");
56853 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr);
56854 return nativeResponseValue;
56856 // void ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56858 export function ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
56859 if(!isWasmInitialized) {
56860 throw new Error("initializeWasm() must be awaited first!");
56862 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr, val);
56863 // debug statements here
56865 // uint64_t ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56867 export function ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
56868 if(!isWasmInitialized) {
56869 throw new Error("initializeWasm() must be awaited first!");
56871 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr);
56872 return nativeResponseValue;
56874 // void ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
56876 export function ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
56877 if(!isWasmInitialized) {
56878 throw new Error("initializeWasm() must be awaited first!");
56880 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr, val);
56881 // debug statements here
56883 // bool ProbabilisticScoringFeeParameters_get_linear_success_probability(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
56885 export function ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr: bigint): boolean {
56886 if(!isWasmInitialized) {
56887 throw new Error("initializeWasm() must be awaited first!");
56889 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr);
56890 return nativeResponseValue;
56892 // void ProbabilisticScoringFeeParameters_set_linear_success_probability(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, bool val);
56894 export function ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr: bigint, val: boolean): void {
56895 if(!isWasmInitialized) {
56896 throw new Error("initializeWasm() must be awaited first!");
56898 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr, val);
56899 // debug statements here
56901 // uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg);
56903 export function ProbabilisticScoringFeeParameters_clone_ptr(arg: bigint): bigint {
56904 if(!isWasmInitialized) {
56905 throw new Error("initializeWasm() must be awaited first!");
56907 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone_ptr(arg);
56908 return nativeResponseValue;
56910 // struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_clone(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR orig);
56912 export function ProbabilisticScoringFeeParameters_clone(orig: bigint): bigint {
56913 if(!isWasmInitialized) {
56914 throw new Error("initializeWasm() must be awaited first!");
56916 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone(orig);
56917 return nativeResponseValue;
56919 // MUST_USE_RES struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_default(void);
56921 export function ProbabilisticScoringFeeParameters_default(): bigint {
56922 if(!isWasmInitialized) {
56923 throw new Error("initializeWasm() must be awaited first!");
56925 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_default();
56926 return nativeResponseValue;
56928 // void ProbabilisticScoringFeeParameters_add_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
56930 export function ProbabilisticScoringFeeParameters_add_banned(this_arg: bigint, node_id: bigint): void {
56931 if(!isWasmInitialized) {
56932 throw new Error("initializeWasm() must be awaited first!");
56934 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned(this_arg, node_id);
56935 // debug statements here
56937 // void ProbabilisticScoringFeeParameters_add_banned_from_list(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
56939 export function ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
56940 if(!isWasmInitialized) {
56941 throw new Error("initializeWasm() must be awaited first!");
56943 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg, node_ids);
56944 // debug statements here
56946 // void ProbabilisticScoringFeeParameters_remove_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
56948 export function ProbabilisticScoringFeeParameters_remove_banned(this_arg: bigint, node_id: bigint): void {
56949 if(!isWasmInitialized) {
56950 throw new Error("initializeWasm() must be awaited first!");
56952 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_banned(this_arg, node_id);
56953 // debug statements here
56955 // void ProbabilisticScoringFeeParameters_set_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
56957 export function ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
56958 if(!isWasmInitialized) {
56959 throw new Error("initializeWasm() must be awaited first!");
56961 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg, node_id, penalty);
56962 // debug statements here
56964 // void ProbabilisticScoringFeeParameters_remove_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
56966 export function ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
56967 if(!isWasmInitialized) {
56968 throw new Error("initializeWasm() must be awaited first!");
56970 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg, node_id);
56971 // debug statements here
56973 // void ProbabilisticScoringFeeParameters_clear_manual_penalties(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg);
56975 export function ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg: bigint): void {
56976 if(!isWasmInitialized) {
56977 throw new Error("initializeWasm() must be awaited first!");
56979 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg);
56980 // debug statements here
56982 // void ProbabilisticScoringDecayParameters_free(struct LDKProbabilisticScoringDecayParameters this_obj);
56984 export function ProbabilisticScoringDecayParameters_free(this_obj: bigint): void {
56985 if(!isWasmInitialized) {
56986 throw new Error("initializeWasm() must be awaited first!");
56988 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_free(this_obj);
56989 // debug statements here
56991 // uint64_t ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
56993 export function ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
56994 if(!isWasmInitialized) {
56995 throw new Error("initializeWasm() must be awaited first!");
56997 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr);
56998 return nativeResponseValue;
57000 // void ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
57002 export function ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
57003 if(!isWasmInitialized) {
57004 throw new Error("initializeWasm() must be awaited first!");
57006 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr, val);
57007 // debug statements here
57009 // uint64_t ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
57011 export function ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
57012 if(!isWasmInitialized) {
57013 throw new Error("initializeWasm() must be awaited first!");
57015 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr);
57016 return nativeResponseValue;
57018 // void ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
57020 export function ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
57021 if(!isWasmInitialized) {
57022 throw new Error("initializeWasm() must be awaited first!");
57024 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr, val);
57025 // debug statements here
57027 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_new(uint64_t historical_no_updates_half_life_arg, uint64_t liquidity_offset_half_life_arg);
57029 export function ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg: bigint, liquidity_offset_half_life_arg: bigint): bigint {
57030 if(!isWasmInitialized) {
57031 throw new Error("initializeWasm() must be awaited first!");
57033 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
57034 return nativeResponseValue;
57036 // uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg);
57038 export function ProbabilisticScoringDecayParameters_clone_ptr(arg: bigint): bigint {
57039 if(!isWasmInitialized) {
57040 throw new Error("initializeWasm() must be awaited first!");
57042 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone_ptr(arg);
57043 return nativeResponseValue;
57045 // struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_clone(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR orig);
57047 export function ProbabilisticScoringDecayParameters_clone(orig: bigint): bigint {
57048 if(!isWasmInitialized) {
57049 throw new Error("initializeWasm() must be awaited first!");
57051 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone(orig);
57052 return nativeResponseValue;
57054 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_default(void);
57056 export function ProbabilisticScoringDecayParameters_default(): bigint {
57057 if(!isWasmInitialized) {
57058 throw new Error("initializeWasm() must be awaited first!");
57060 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_default();
57061 return nativeResponseValue;
57063 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringDecayParameters decay_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
57065 export function ProbabilisticScorer_new(decay_params: bigint, network_graph: bigint, logger: bigint): bigint {
57066 if(!isWasmInitialized) {
57067 throw new Error("initializeWasm() must be awaited first!");
57069 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(decay_params, network_graph, logger);
57070 return nativeResponseValue;
57072 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
57074 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
57075 if(!isWasmInitialized) {
57076 throw new Error("initializeWasm() must be awaited first!");
57078 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
57079 // debug statements here
57081 // 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);
57083 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
57084 if(!isWasmInitialized) {
57085 throw new Error("initializeWasm() must be awaited first!");
57087 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
57088 return nativeResponseValue;
57090 // MUST_USE_RES struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
57092 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
57093 if(!isWasmInitialized) {
57094 throw new Error("initializeWasm() must be awaited first!");
57096 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
57097 return nativeResponseValue;
57099 // MUST_USE_RES struct LDKCOption_f64Z ProbabilisticScorer_historical_estimated_payment_success_probability(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target, uint64_t amount_msat, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR params);
57101 export function ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg: bigint, scid: bigint, target: bigint, amount_msat: bigint, params: bigint): bigint {
57102 if(!isWasmInitialized) {
57103 throw new Error("initializeWasm() must be awaited first!");
57105 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg, scid, target, amount_msat, params);
57106 return nativeResponseValue;
57108 // struct LDKScoreLookUp ProbabilisticScorer_as_ScoreLookUp(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
57110 export function ProbabilisticScorer_as_ScoreLookUp(this_arg: bigint): bigint {
57111 if(!isWasmInitialized) {
57112 throw new Error("initializeWasm() must be awaited first!");
57114 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreLookUp(this_arg);
57115 return nativeResponseValue;
57117 // struct LDKScoreUpdate ProbabilisticScorer_as_ScoreUpdate(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
57119 export function ProbabilisticScorer_as_ScoreUpdate(this_arg: bigint): bigint {
57120 if(!isWasmInitialized) {
57121 throw new Error("initializeWasm() must be awaited first!");
57123 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreUpdate(this_arg);
57124 return nativeResponseValue;
57126 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
57128 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
57129 if(!isWasmInitialized) {
57130 throw new Error("initializeWasm() must be awaited first!");
57132 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
57133 return nativeResponseValue;
57135 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
57137 export function ProbabilisticScorer_write(obj: bigint): number {
57138 if(!isWasmInitialized) {
57139 throw new Error("initializeWasm() must be awaited first!");
57141 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
57142 return nativeResponseValue;
57144 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringDecayParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
57146 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
57147 if(!isWasmInitialized) {
57148 throw new Error("initializeWasm() must be awaited first!");
57150 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
57151 return nativeResponseValue;
57153 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
57155 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
57156 if(!isWasmInitialized) {
57157 throw new Error("initializeWasm() must be awaited first!");
57159 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
57160 // debug statements here
57162 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57164 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
57165 if(!isWasmInitialized) {
57166 throw new Error("initializeWasm() must be awaited first!");
57168 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
57169 return nativeResponseValue;
57171 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
57173 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
57174 if(!isWasmInitialized) {
57175 throw new Error("initializeWasm() must be awaited first!");
57177 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
57178 // debug statements here
57180 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57182 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
57183 if(!isWasmInitialized) {
57184 throw new Error("initializeWasm() must be awaited first!");
57186 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
57187 return nativeResponseValue;
57189 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
57191 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
57192 if(!isWasmInitialized) {
57193 throw new Error("initializeWasm() must be awaited first!");
57195 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
57196 // debug statements here
57198 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57200 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
57201 if(!isWasmInitialized) {
57202 throw new Error("initializeWasm() must be awaited first!");
57204 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
57205 return nativeResponseValue;
57207 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
57209 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
57210 if(!isWasmInitialized) {
57211 throw new Error("initializeWasm() must be awaited first!");
57213 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
57214 // debug statements here
57216 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57218 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
57219 if(!isWasmInitialized) {
57220 throw new Error("initializeWasm() must be awaited first!");
57222 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
57223 return nativeResponseValue;
57225 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
57227 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
57228 if(!isWasmInitialized) {
57229 throw new Error("initializeWasm() must be awaited first!");
57231 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
57232 // debug statements here
57234 // struct LDKRevocationKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57236 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): bigint {
57237 if(!isWasmInitialized) {
57238 throw new Error("initializeWasm() must be awaited first!");
57240 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
57241 return nativeResponseValue;
57243 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKRevocationKey val);
57245 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: bigint): void {
57246 if(!isWasmInitialized) {
57247 throw new Error("initializeWasm() must be awaited first!");
57249 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
57250 // debug statements here
57252 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
57254 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
57255 if(!isWasmInitialized) {
57256 throw new Error("initializeWasm() must be awaited first!");
57258 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
57259 return nativeResponseValue;
57261 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
57263 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
57264 if(!isWasmInitialized) {
57265 throw new Error("initializeWasm() must be awaited first!");
57267 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
57268 // debug statements here
57270 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57272 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
57273 if(!isWasmInitialized) {
57274 throw new Error("initializeWasm() must be awaited first!");
57276 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
57277 return nativeResponseValue;
57279 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
57281 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
57282 if(!isWasmInitialized) {
57283 throw new Error("initializeWasm() must be awaited first!");
57285 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
57286 // debug statements here
57288 // struct LDKChannelTransactionParameters DelayedPaymentOutputDescriptor_get_channel_transaction_parameters(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57290 export function DelayedPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr: bigint): bigint {
57291 if(!isWasmInitialized) {
57292 throw new Error("initializeWasm() must be awaited first!");
57294 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr);
57295 return nativeResponseValue;
57297 // void DelayedPaymentOutputDescriptor_set_channel_transaction_parameters(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
57299 export function DelayedPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr: bigint, val: bigint): void {
57300 if(!isWasmInitialized) {
57301 throw new Error("initializeWasm() must be awaited first!");
57303 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr, val);
57304 // debug statements here
57306 // 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 LDKRevocationKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg, struct LDKChannelTransactionParameters channel_transaction_parameters_arg);
57308 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: bigint, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: bigint, revocation_pubkey_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint, channel_transaction_parameters_arg: bigint): bigint {
57309 if(!isWasmInitialized) {
57310 throw new Error("initializeWasm() must be awaited first!");
57312 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, channel_transaction_parameters_arg);
57313 return nativeResponseValue;
57315 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
57317 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
57318 if(!isWasmInitialized) {
57319 throw new Error("initializeWasm() must be awaited first!");
57321 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
57322 return nativeResponseValue;
57324 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
57326 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
57327 if(!isWasmInitialized) {
57328 throw new Error("initializeWasm() must be awaited first!");
57330 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
57331 return nativeResponseValue;
57333 // uint64_t DelayedPaymentOutputDescriptor_hash(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR o);
57335 export function DelayedPaymentOutputDescriptor_hash(o: bigint): bigint {
57336 if(!isWasmInitialized) {
57337 throw new Error("initializeWasm() must be awaited first!");
57339 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_hash(o);
57340 return nativeResponseValue;
57342 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
57344 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
57345 if(!isWasmInitialized) {
57346 throw new Error("initializeWasm() must be awaited first!");
57348 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
57349 return nativeResponseValue;
57351 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
57353 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
57354 if(!isWasmInitialized) {
57355 throw new Error("initializeWasm() must be awaited first!");
57357 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
57358 return nativeResponseValue;
57360 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
57362 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
57363 if(!isWasmInitialized) {
57364 throw new Error("initializeWasm() must be awaited first!");
57366 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
57367 return nativeResponseValue;
57369 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
57371 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
57372 if(!isWasmInitialized) {
57373 throw new Error("initializeWasm() must be awaited first!");
57375 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
57376 // debug statements here
57378 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57380 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
57381 if(!isWasmInitialized) {
57382 throw new Error("initializeWasm() must be awaited first!");
57384 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
57385 return nativeResponseValue;
57387 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
57389 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
57390 if(!isWasmInitialized) {
57391 throw new Error("initializeWasm() must be awaited first!");
57393 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
57394 // debug statements here
57396 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57398 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
57399 if(!isWasmInitialized) {
57400 throw new Error("initializeWasm() must be awaited first!");
57402 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
57403 return nativeResponseValue;
57405 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
57407 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
57408 if(!isWasmInitialized) {
57409 throw new Error("initializeWasm() must be awaited first!");
57411 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
57412 // debug statements here
57414 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
57416 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
57417 if(!isWasmInitialized) {
57418 throw new Error("initializeWasm() must be awaited first!");
57420 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
57421 return nativeResponseValue;
57423 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
57425 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
57426 if(!isWasmInitialized) {
57427 throw new Error("initializeWasm() must be awaited first!");
57429 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
57430 // debug statements here
57432 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57434 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
57435 if(!isWasmInitialized) {
57436 throw new Error("initializeWasm() must be awaited first!");
57438 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
57439 return nativeResponseValue;
57441 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
57443 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
57444 if(!isWasmInitialized) {
57445 throw new Error("initializeWasm() must be awaited first!");
57447 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
57448 // debug statements here
57450 // struct LDKChannelTransactionParameters StaticPaymentOutputDescriptor_get_channel_transaction_parameters(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
57452 export function StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr: bigint): bigint {
57453 if(!isWasmInitialized) {
57454 throw new Error("initializeWasm() must be awaited first!");
57456 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr);
57457 return nativeResponseValue;
57459 // void StaticPaymentOutputDescriptor_set_channel_transaction_parameters(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
57461 export function StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr: bigint, val: bigint): void {
57462 if(!isWasmInitialized) {
57463 throw new Error("initializeWasm() must be awaited first!");
57465 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr, val);
57466 // debug statements here
57468 // 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, struct LDKChannelTransactionParameters channel_transaction_parameters_arg);
57470 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint, channel_transaction_parameters_arg: bigint): bigint {
57471 if(!isWasmInitialized) {
57472 throw new Error("initializeWasm() must be awaited first!");
57474 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg, channel_transaction_parameters_arg);
57475 return nativeResponseValue;
57477 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
57479 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
57480 if(!isWasmInitialized) {
57481 throw new Error("initializeWasm() must be awaited first!");
57483 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
57484 return nativeResponseValue;
57486 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
57488 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
57489 if(!isWasmInitialized) {
57490 throw new Error("initializeWasm() must be awaited first!");
57492 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
57493 return nativeResponseValue;
57495 // uint64_t StaticPaymentOutputDescriptor_hash(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR o);
57497 export function StaticPaymentOutputDescriptor_hash(o: bigint): bigint {
57498 if(!isWasmInitialized) {
57499 throw new Error("initializeWasm() must be awaited first!");
57501 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_hash(o);
57502 return nativeResponseValue;
57504 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
57506 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
57507 if(!isWasmInitialized) {
57508 throw new Error("initializeWasm() must be awaited first!");
57510 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
57511 return nativeResponseValue;
57513 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ StaticPaymentOutputDescriptor_witness_script(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
57515 export function StaticPaymentOutputDescriptor_witness_script(this_arg: bigint): bigint {
57516 if(!isWasmInitialized) {
57517 throw new Error("initializeWasm() must be awaited first!");
57519 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_witness_script(this_arg);
57520 return nativeResponseValue;
57522 // MUST_USE_RES uint64_t StaticPaymentOutputDescriptor_max_witness_length(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
57524 export function StaticPaymentOutputDescriptor_max_witness_length(this_arg: bigint): bigint {
57525 if(!isWasmInitialized) {
57526 throw new Error("initializeWasm() must be awaited first!");
57528 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_max_witness_length(this_arg);
57529 return nativeResponseValue;
57531 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
57533 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
57534 if(!isWasmInitialized) {
57535 throw new Error("initializeWasm() must be awaited first!");
57537 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
57538 return nativeResponseValue;
57540 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
57542 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
57543 if(!isWasmInitialized) {
57544 throw new Error("initializeWasm() must be awaited first!");
57546 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
57547 return nativeResponseValue;
57549 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
57551 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
57552 if(!isWasmInitialized) {
57553 throw new Error("initializeWasm() must be awaited first!");
57555 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
57556 // debug statements here
57558 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
57560 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
57561 if(!isWasmInitialized) {
57562 throw new Error("initializeWasm() must be awaited first!");
57564 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
57565 return nativeResponseValue;
57567 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
57569 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
57570 if(!isWasmInitialized) {
57571 throw new Error("initializeWasm() must be awaited first!");
57573 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
57574 return nativeResponseValue;
57576 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output, struct LDKThirtyTwoBytes channel_keys_id);
57578 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint, channel_keys_id: number): bigint {
57579 if(!isWasmInitialized) {
57580 throw new Error("initializeWasm() must be awaited first!");
57582 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output, channel_keys_id);
57583 return nativeResponseValue;
57585 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
57587 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
57588 if(!isWasmInitialized) {
57589 throw new Error("initializeWasm() must be awaited first!");
57591 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
57592 return nativeResponseValue;
57594 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
57596 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
57597 if(!isWasmInitialized) {
57598 throw new Error("initializeWasm() must be awaited first!");
57600 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
57601 return nativeResponseValue;
57603 // uint64_t SpendableOutputDescriptor_hash(const struct LDKSpendableOutputDescriptor *NONNULL_PTR o);
57605 export function SpendableOutputDescriptor_hash(o: bigint): bigint {
57606 if(!isWasmInitialized) {
57607 throw new Error("initializeWasm() must be awaited first!");
57609 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_hash(o);
57610 return nativeResponseValue;
57612 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
57614 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
57615 if(!isWasmInitialized) {
57616 throw new Error("initializeWasm() must be awaited first!");
57618 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
57619 return nativeResponseValue;
57621 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
57623 export function SpendableOutputDescriptor_write(obj: bigint): number {
57624 if(!isWasmInitialized) {
57625 throw new Error("initializeWasm() must be awaited first!");
57627 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
57628 return nativeResponseValue;
57630 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
57632 export function SpendableOutputDescriptor_read(ser: number): bigint {
57633 if(!isWasmInitialized) {
57634 throw new Error("initializeWasm() must be awaited first!");
57636 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
57637 return nativeResponseValue;
57639 // MUST_USE_RES struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ SpendableOutputDescriptor_create_spendable_outputs_psbt(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
57641 export function SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
57642 if(!isWasmInitialized) {
57643 throw new Error("initializeWasm() must be awaited first!");
57645 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
57646 return nativeResponseValue;
57648 // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
57650 export function ChannelDerivationParameters_free(this_obj: bigint): void {
57651 if(!isWasmInitialized) {
57652 throw new Error("initializeWasm() must be awaited first!");
57654 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
57655 // debug statements here
57657 // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
57659 export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
57660 if(!isWasmInitialized) {
57661 throw new Error("initializeWasm() must be awaited first!");
57663 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
57664 return nativeResponseValue;
57666 // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
57668 export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
57669 if(!isWasmInitialized) {
57670 throw new Error("initializeWasm() must be awaited first!");
57672 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
57673 // debug statements here
57675 // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
57677 export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
57678 if(!isWasmInitialized) {
57679 throw new Error("initializeWasm() must be awaited first!");
57681 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
57682 return nativeResponseValue;
57684 // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
57686 export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
57687 if(!isWasmInitialized) {
57688 throw new Error("initializeWasm() must be awaited first!");
57690 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
57691 // debug statements here
57693 // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
57695 export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
57696 if(!isWasmInitialized) {
57697 throw new Error("initializeWasm() must be awaited first!");
57699 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
57700 return nativeResponseValue;
57702 // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
57704 export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
57705 if(!isWasmInitialized) {
57706 throw new Error("initializeWasm() must be awaited first!");
57708 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
57709 // debug statements here
57711 // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
57713 export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
57714 if(!isWasmInitialized) {
57715 throw new Error("initializeWasm() must be awaited first!");
57717 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
57718 return nativeResponseValue;
57720 // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
57722 export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
57723 if(!isWasmInitialized) {
57724 throw new Error("initializeWasm() must be awaited first!");
57726 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
57727 return nativeResponseValue;
57729 // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
57731 export function ChannelDerivationParameters_clone(orig: bigint): bigint {
57732 if(!isWasmInitialized) {
57733 throw new Error("initializeWasm() must be awaited first!");
57735 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
57736 return nativeResponseValue;
57738 // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
57740 export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
57741 if(!isWasmInitialized) {
57742 throw new Error("initializeWasm() must be awaited first!");
57744 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
57745 return nativeResponseValue;
57747 // struct LDKCVec_u8Z ChannelDerivationParameters_write(const struct LDKChannelDerivationParameters *NONNULL_PTR obj);
57749 export function ChannelDerivationParameters_write(obj: bigint): number {
57750 if(!isWasmInitialized) {
57751 throw new Error("initializeWasm() must be awaited first!");
57753 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_write(obj);
57754 return nativeResponseValue;
57756 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ ChannelDerivationParameters_read(struct LDKu8slice ser);
57758 export function ChannelDerivationParameters_read(ser: number): bigint {
57759 if(!isWasmInitialized) {
57760 throw new Error("initializeWasm() must be awaited first!");
57762 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_read(ser);
57763 return nativeResponseValue;
57765 // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
57767 export function HTLCDescriptor_free(this_obj: bigint): void {
57768 if(!isWasmInitialized) {
57769 throw new Error("initializeWasm() must be awaited first!");
57771 const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
57772 // debug statements here
57774 // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57776 export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
57777 if(!isWasmInitialized) {
57778 throw new Error("initializeWasm() must be awaited first!");
57780 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
57781 return nativeResponseValue;
57783 // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
57785 export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
57786 if(!isWasmInitialized) {
57787 throw new Error("initializeWasm() must be awaited first!");
57789 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
57790 // debug statements here
57792 // const uint8_t (*HTLCDescriptor_get_commitment_txid(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr))[32];
57794 export function HTLCDescriptor_get_commitment_txid(this_ptr: bigint): number {
57795 if(!isWasmInitialized) {
57796 throw new Error("initializeWasm() must be awaited first!");
57798 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_commitment_txid(this_ptr);
57799 return nativeResponseValue;
57801 // void HTLCDescriptor_set_commitment_txid(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
57803 export function HTLCDescriptor_set_commitment_txid(this_ptr: bigint, val: number): void {
57804 if(!isWasmInitialized) {
57805 throw new Error("initializeWasm() must be awaited first!");
57807 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_commitment_txid(this_ptr, val);
57808 // debug statements here
57810 // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57812 export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
57813 if(!isWasmInitialized) {
57814 throw new Error("initializeWasm() must be awaited first!");
57816 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
57817 return nativeResponseValue;
57819 // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
57821 export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
57822 if(!isWasmInitialized) {
57823 throw new Error("initializeWasm() must be awaited first!");
57825 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
57826 // debug statements here
57828 // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57830 export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
57831 if(!isWasmInitialized) {
57832 throw new Error("initializeWasm() must be awaited first!");
57834 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
57835 return nativeResponseValue;
57837 // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
57839 export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
57840 if(!isWasmInitialized) {
57841 throw new Error("initializeWasm() must be awaited first!");
57843 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
57844 // debug statements here
57846 // uint32_t HTLCDescriptor_get_feerate_per_kw(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57848 export function HTLCDescriptor_get_feerate_per_kw(this_ptr: bigint): number {
57849 if(!isWasmInitialized) {
57850 throw new Error("initializeWasm() must be awaited first!");
57852 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_feerate_per_kw(this_ptr);
57853 return nativeResponseValue;
57855 // void HTLCDescriptor_set_feerate_per_kw(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint32_t val);
57857 export function HTLCDescriptor_set_feerate_per_kw(this_ptr: bigint, val: number): void {
57858 if(!isWasmInitialized) {
57859 throw new Error("initializeWasm() must be awaited first!");
57861 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_feerate_per_kw(this_ptr, val);
57862 // debug statements here
57864 // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57866 export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
57867 if(!isWasmInitialized) {
57868 throw new Error("initializeWasm() must be awaited first!");
57870 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
57871 return nativeResponseValue;
57873 // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
57875 export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
57876 if(!isWasmInitialized) {
57877 throw new Error("initializeWasm() must be awaited first!");
57879 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
57880 // debug statements here
57882 // struct LDKCOption_ThirtyTwoBytesZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57884 export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
57885 if(!isWasmInitialized) {
57886 throw new Error("initializeWasm() must be awaited first!");
57888 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
57889 return nativeResponseValue;
57891 // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
57893 export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
57894 if(!isWasmInitialized) {
57895 throw new Error("initializeWasm() must be awaited first!");
57897 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
57898 // debug statements here
57900 // struct LDKECDSASignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
57902 export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
57903 if(!isWasmInitialized) {
57904 throw new Error("initializeWasm() must be awaited first!");
57906 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
57907 return nativeResponseValue;
57909 // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
57911 export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
57912 if(!isWasmInitialized) {
57913 throw new Error("initializeWasm() must be awaited first!");
57915 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
57916 // debug statements here
57918 // MUST_USE_RES struct LDKHTLCDescriptor HTLCDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKThirtyTwoBytes commitment_txid_arg, uint64_t per_commitment_number_arg, struct LDKPublicKey per_commitment_point_arg, uint32_t feerate_per_kw_arg, struct LDKHTLCOutputInCommitment htlc_arg, struct LDKCOption_ThirtyTwoBytesZ preimage_arg, struct LDKECDSASignature counterparty_sig_arg);
57920 export function HTLCDescriptor_new(channel_derivation_parameters_arg: bigint, commitment_txid_arg: number, per_commitment_number_arg: bigint, per_commitment_point_arg: number, feerate_per_kw_arg: number, htlc_arg: bigint, preimage_arg: bigint, counterparty_sig_arg: number): bigint {
57921 if(!isWasmInitialized) {
57922 throw new Error("initializeWasm() must be awaited first!");
57924 const nativeResponseValue = wasm.TS_HTLCDescriptor_new(channel_derivation_parameters_arg, commitment_txid_arg, per_commitment_number_arg, per_commitment_point_arg, feerate_per_kw_arg, htlc_arg, preimage_arg, counterparty_sig_arg);
57925 return nativeResponseValue;
57927 // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
57929 export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
57930 if(!isWasmInitialized) {
57931 throw new Error("initializeWasm() must be awaited first!");
57933 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
57934 return nativeResponseValue;
57936 // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
57938 export function HTLCDescriptor_clone(orig: bigint): bigint {
57939 if(!isWasmInitialized) {
57940 throw new Error("initializeWasm() must be awaited first!");
57942 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
57943 return nativeResponseValue;
57945 // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
57947 export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
57948 if(!isWasmInitialized) {
57949 throw new Error("initializeWasm() must be awaited first!");
57951 const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
57952 return nativeResponseValue;
57954 // struct LDKCVec_u8Z HTLCDescriptor_write(const struct LDKHTLCDescriptor *NONNULL_PTR obj);
57956 export function HTLCDescriptor_write(obj: bigint): number {
57957 if(!isWasmInitialized) {
57958 throw new Error("initializeWasm() must be awaited first!");
57960 const nativeResponseValue = wasm.TS_HTLCDescriptor_write(obj);
57961 return nativeResponseValue;
57963 // struct LDKCResult_HTLCDescriptorDecodeErrorZ HTLCDescriptor_read(struct LDKu8slice ser);
57965 export function HTLCDescriptor_read(ser: number): bigint {
57966 if(!isWasmInitialized) {
57967 throw new Error("initializeWasm() must be awaited first!");
57969 const nativeResponseValue = wasm.TS_HTLCDescriptor_read(ser);
57970 return nativeResponseValue;
57972 // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
57974 export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
57975 if(!isWasmInitialized) {
57976 throw new Error("initializeWasm() must be awaited first!");
57978 const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
57979 return nativeResponseValue;
57981 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
57983 export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
57984 if(!isWasmInitialized) {
57985 throw new Error("initializeWasm() must be awaited first!");
57987 const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
57988 return nativeResponseValue;
57990 // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
57992 export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
57993 if(!isWasmInitialized) {
57994 throw new Error("initializeWasm() must be awaited first!");
57996 const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
57997 return nativeResponseValue;
57999 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
58001 export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
58002 if(!isWasmInitialized) {
58003 throw new Error("initializeWasm() must be awaited first!");
58005 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
58006 return nativeResponseValue;
58008 // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
58010 export function HTLCDescriptor_witness_script(this_arg: bigint): number {
58011 if(!isWasmInitialized) {
58012 throw new Error("initializeWasm() must be awaited first!");
58014 const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
58015 return nativeResponseValue;
58017 // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature, struct LDKu8slice witness_script);
58019 export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
58020 if(!isWasmInitialized) {
58021 throw new Error("initializeWasm() must be awaited first!");
58023 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
58024 return nativeResponseValue;
58026 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
58028 export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
58029 if(!isWasmInitialized) {
58030 throw new Error("initializeWasm() must be awaited first!");
58032 const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
58033 return nativeResponseValue;
58035 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
58037 export function ChannelSigner_free(this_ptr: bigint): void {
58038 if(!isWasmInitialized) {
58039 throw new Error("initializeWasm() must be awaited first!");
58041 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
58042 // debug statements here
58044 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
58046 export function Recipient_clone(orig: bigint): Recipient {
58047 if(!isWasmInitialized) {
58048 throw new Error("initializeWasm() must be awaited first!");
58050 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
58051 return nativeResponseValue;
58053 // enum LDKRecipient Recipient_node(void);
58055 export function Recipient_node(): Recipient {
58056 if(!isWasmInitialized) {
58057 throw new Error("initializeWasm() must be awaited first!");
58059 const nativeResponseValue = wasm.TS_Recipient_node();
58060 return nativeResponseValue;
58062 // enum LDKRecipient Recipient_phantom_node(void);
58064 export function Recipient_phantom_node(): Recipient {
58065 if(!isWasmInitialized) {
58066 throw new Error("initializeWasm() must be awaited first!");
58068 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
58069 return nativeResponseValue;
58071 // void EntropySource_free(struct LDKEntropySource this_ptr);
58073 export function EntropySource_free(this_ptr: bigint): void {
58074 if(!isWasmInitialized) {
58075 throw new Error("initializeWasm() must be awaited first!");
58077 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
58078 // debug statements here
58080 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
58082 export function NodeSigner_free(this_ptr: bigint): void {
58083 if(!isWasmInitialized) {
58084 throw new Error("initializeWasm() must be awaited first!");
58086 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
58087 // debug statements here
58089 // void OutputSpender_free(struct LDKOutputSpender this_ptr);
58091 export function OutputSpender_free(this_ptr: bigint): void {
58092 if(!isWasmInitialized) {
58093 throw new Error("initializeWasm() must be awaited first!");
58095 const nativeResponseValue = wasm.TS_OutputSpender_free(this_ptr);
58096 // debug statements here
58098 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
58100 export function SignerProvider_free(this_ptr: bigint): void {
58101 if(!isWasmInitialized) {
58102 throw new Error("initializeWasm() must be awaited first!");
58104 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
58105 // debug statements here
58107 // void ChangeDestinationSource_free(struct LDKChangeDestinationSource this_ptr);
58109 export function ChangeDestinationSource_free(this_ptr: bigint): void {
58110 if(!isWasmInitialized) {
58111 throw new Error("initializeWasm() must be awaited first!");
58113 const nativeResponseValue = wasm.TS_ChangeDestinationSource_free(this_ptr);
58114 // debug statements here
58116 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
58118 export function InMemorySigner_free(this_obj: bigint): void {
58119 if(!isWasmInitialized) {
58120 throw new Error("initializeWasm() must be awaited first!");
58122 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
58123 // debug statements here
58125 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58127 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
58128 if(!isWasmInitialized) {
58129 throw new Error("initializeWasm() must be awaited first!");
58131 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
58132 return nativeResponseValue;
58134 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
58136 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
58137 if(!isWasmInitialized) {
58138 throw new Error("initializeWasm() must be awaited first!");
58140 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
58141 // debug statements here
58143 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58145 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
58146 if(!isWasmInitialized) {
58147 throw new Error("initializeWasm() must be awaited first!");
58149 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
58150 return nativeResponseValue;
58152 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
58154 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
58155 if(!isWasmInitialized) {
58156 throw new Error("initializeWasm() must be awaited first!");
58158 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
58159 // debug statements here
58161 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58163 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
58164 if(!isWasmInitialized) {
58165 throw new Error("initializeWasm() must be awaited first!");
58167 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
58168 return nativeResponseValue;
58170 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
58172 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
58173 if(!isWasmInitialized) {
58174 throw new Error("initializeWasm() must be awaited first!");
58176 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
58177 // debug statements here
58179 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58181 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
58182 if(!isWasmInitialized) {
58183 throw new Error("initializeWasm() must be awaited first!");
58185 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
58186 return nativeResponseValue;
58188 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
58190 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
58191 if(!isWasmInitialized) {
58192 throw new Error("initializeWasm() must be awaited first!");
58194 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
58195 // debug statements here
58197 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58199 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
58200 if(!isWasmInitialized) {
58201 throw new Error("initializeWasm() must be awaited first!");
58203 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
58204 return nativeResponseValue;
58206 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
58208 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
58209 if(!isWasmInitialized) {
58210 throw new Error("initializeWasm() must be awaited first!");
58212 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
58213 // debug statements here
58215 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
58217 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
58218 if(!isWasmInitialized) {
58219 throw new Error("initializeWasm() must be awaited first!");
58221 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
58222 return nativeResponseValue;
58224 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
58226 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
58227 if(!isWasmInitialized) {
58228 throw new Error("initializeWasm() must be awaited first!");
58230 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
58231 // debug statements here
58233 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
58235 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
58236 if(!isWasmInitialized) {
58237 throw new Error("initializeWasm() must be awaited first!");
58239 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
58240 return nativeResponseValue;
58242 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
58244 export function InMemorySigner_clone(orig: bigint): bigint {
58245 if(!isWasmInitialized) {
58246 throw new Error("initializeWasm() must be awaited first!");
58248 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
58249 return nativeResponseValue;
58251 // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(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, struct LDKThirtyTwoBytes rand_bytes_unique_start);
58253 export function InMemorySigner_new(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, rand_bytes_unique_start: number): bigint {
58254 if(!isWasmInitialized) {
58255 throw new Error("initializeWasm() must be awaited first!");
58257 const nativeResponseValue = wasm.TS_InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id, rand_bytes_unique_start);
58258 return nativeResponseValue;
58260 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58262 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
58263 if(!isWasmInitialized) {
58264 throw new Error("initializeWasm() must be awaited first!");
58266 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
58267 return nativeResponseValue;
58269 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58271 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): bigint {
58272 if(!isWasmInitialized) {
58273 throw new Error("initializeWasm() must be awaited first!");
58275 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
58276 return nativeResponseValue;
58278 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58280 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): bigint {
58281 if(!isWasmInitialized) {
58282 throw new Error("initializeWasm() must be awaited first!");
58284 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
58285 return nativeResponseValue;
58287 // MUST_USE_RES struct LDKCOption_boolZ InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58289 export function InMemorySigner_is_outbound(this_arg: bigint): bigint {
58290 if(!isWasmInitialized) {
58291 throw new Error("initializeWasm() must be awaited first!");
58293 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
58294 return nativeResponseValue;
58296 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58298 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
58299 if(!isWasmInitialized) {
58300 throw new Error("initializeWasm() must be awaited first!");
58302 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
58303 return nativeResponseValue;
58305 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58307 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
58308 if(!isWasmInitialized) {
58309 throw new Error("initializeWasm() must be awaited first!");
58311 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
58312 return nativeResponseValue;
58314 // MUST_USE_RES struct LDKChannelTypeFeatures InMemorySigner_channel_type_features(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58316 export function InMemorySigner_channel_type_features(this_arg: bigint): bigint {
58317 if(!isWasmInitialized) {
58318 throw new Error("initializeWasm() must be awaited first!");
58320 const nativeResponseValue = wasm.TS_InMemorySigner_channel_type_features(this_arg);
58321 return nativeResponseValue;
58323 // MUST_USE_RES struct LDKCResult_WitnessNoneZ 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);
58325 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
58326 if(!isWasmInitialized) {
58327 throw new Error("initializeWasm() must be awaited first!");
58329 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
58330 return nativeResponseValue;
58332 // MUST_USE_RES struct LDKCResult_WitnessNoneZ 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);
58334 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
58335 if(!isWasmInitialized) {
58336 throw new Error("initializeWasm() must be awaited first!");
58338 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
58339 return nativeResponseValue;
58341 // struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58343 export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
58344 if(!isWasmInitialized) {
58345 throw new Error("initializeWasm() must be awaited first!");
58347 const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
58348 return nativeResponseValue;
58350 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58352 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
58353 if(!isWasmInitialized) {
58354 throw new Error("initializeWasm() must be awaited first!");
58356 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
58357 return nativeResponseValue;
58359 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58361 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
58362 if(!isWasmInitialized) {
58363 throw new Error("initializeWasm() must be awaited first!");
58365 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
58366 return nativeResponseValue;
58368 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
58370 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
58371 if(!isWasmInitialized) {
58372 throw new Error("initializeWasm() must be awaited first!");
58374 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
58375 return nativeResponseValue;
58377 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
58379 export function InMemorySigner_write(obj: bigint): number {
58380 if(!isWasmInitialized) {
58381 throw new Error("initializeWasm() must be awaited first!");
58383 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
58384 return nativeResponseValue;
58386 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
58388 export function InMemorySigner_read(ser: number, arg: bigint): bigint {
58389 if(!isWasmInitialized) {
58390 throw new Error("initializeWasm() must be awaited first!");
58392 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
58393 return nativeResponseValue;
58395 // void KeysManager_free(struct LDKKeysManager this_obj);
58397 export function KeysManager_free(this_obj: bigint): void {
58398 if(!isWasmInitialized) {
58399 throw new Error("initializeWasm() must be awaited first!");
58401 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
58402 // debug statements here
58404 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
58406 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
58407 if(!isWasmInitialized) {
58408 throw new Error("initializeWasm() must be awaited first!");
58410 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
58411 return nativeResponseValue;
58413 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
58415 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
58416 if(!isWasmInitialized) {
58417 throw new Error("initializeWasm() must be awaited first!");
58419 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
58420 return nativeResponseValue;
58422 // 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]);
58424 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
58425 if(!isWasmInitialized) {
58426 throw new Error("initializeWasm() must be awaited first!");
58428 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
58429 return nativeResponseValue;
58431 // MUST_USE_RES struct LDKCResult_CVec_u8ZNoneZ KeysManager_sign_spendable_outputs_psbt(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_u8Z psbt);
58433 export function KeysManager_sign_spendable_outputs_psbt(this_arg: bigint, descriptors: number, psbt: number): bigint {
58434 if(!isWasmInitialized) {
58435 throw new Error("initializeWasm() must be awaited first!");
58437 const nativeResponseValue = wasm.TS_KeysManager_sign_spendable_outputs_psbt(this_arg, descriptors, psbt);
58438 return nativeResponseValue;
58440 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
58442 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
58443 if(!isWasmInitialized) {
58444 throw new Error("initializeWasm() must be awaited first!");
58446 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
58447 return nativeResponseValue;
58449 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
58451 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
58452 if(!isWasmInitialized) {
58453 throw new Error("initializeWasm() must be awaited first!");
58455 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
58456 return nativeResponseValue;
58458 // struct LDKOutputSpender KeysManager_as_OutputSpender(const struct LDKKeysManager *NONNULL_PTR this_arg);
58460 export function KeysManager_as_OutputSpender(this_arg: bigint): bigint {
58461 if(!isWasmInitialized) {
58462 throw new Error("initializeWasm() must be awaited first!");
58464 const nativeResponseValue = wasm.TS_KeysManager_as_OutputSpender(this_arg);
58465 return nativeResponseValue;
58467 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
58469 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
58470 if(!isWasmInitialized) {
58471 throw new Error("initializeWasm() must be awaited first!");
58473 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
58474 return nativeResponseValue;
58476 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
58478 export function PhantomKeysManager_free(this_obj: bigint): void {
58479 if(!isWasmInitialized) {
58480 throw new Error("initializeWasm() must be awaited first!");
58482 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
58483 // debug statements here
58485 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58487 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
58488 if(!isWasmInitialized) {
58489 throw new Error("initializeWasm() must be awaited first!");
58491 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
58492 return nativeResponseValue;
58494 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58496 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
58497 if(!isWasmInitialized) {
58498 throw new Error("initializeWasm() must be awaited first!");
58500 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
58501 return nativeResponseValue;
58503 // struct LDKOutputSpender PhantomKeysManager_as_OutputSpender(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58505 export function PhantomKeysManager_as_OutputSpender(this_arg: bigint): bigint {
58506 if(!isWasmInitialized) {
58507 throw new Error("initializeWasm() must be awaited first!");
58509 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_OutputSpender(this_arg);
58510 return nativeResponseValue;
58512 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58514 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
58515 if(!isWasmInitialized) {
58516 throw new Error("initializeWasm() must be awaited first!");
58518 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
58519 return nativeResponseValue;
58521 // 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]);
58523 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
58524 if(!isWasmInitialized) {
58525 throw new Error("initializeWasm() must be awaited first!");
58527 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
58528 return nativeResponseValue;
58530 // 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]);
58532 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
58533 if(!isWasmInitialized) {
58534 throw new Error("initializeWasm() must be awaited first!");
58536 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
58537 return nativeResponseValue;
58539 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58541 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
58542 if(!isWasmInitialized) {
58543 throw new Error("initializeWasm() must be awaited first!");
58545 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
58546 return nativeResponseValue;
58548 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
58550 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
58551 if(!isWasmInitialized) {
58552 throw new Error("initializeWasm() must be awaited first!");
58554 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
58555 return nativeResponseValue;
58557 // void RandomBytes_free(struct LDKRandomBytes this_obj);
58559 export function RandomBytes_free(this_obj: bigint): void {
58560 if(!isWasmInitialized) {
58561 throw new Error("initializeWasm() must be awaited first!");
58563 const nativeResponseValue = wasm.TS_RandomBytes_free(this_obj);
58564 // debug statements here
58566 // MUST_USE_RES struct LDKRandomBytes RandomBytes_new(struct LDKThirtyTwoBytes seed);
58568 export function RandomBytes_new(seed: number): bigint {
58569 if(!isWasmInitialized) {
58570 throw new Error("initializeWasm() must be awaited first!");
58572 const nativeResponseValue = wasm.TS_RandomBytes_new(seed);
58573 return nativeResponseValue;
58575 // struct LDKEntropySource RandomBytes_as_EntropySource(const struct LDKRandomBytes *NONNULL_PTR this_arg);
58577 export function RandomBytes_as_EntropySource(this_arg: bigint): bigint {
58578 if(!isWasmInitialized) {
58579 throw new Error("initializeWasm() must be awaited first!");
58581 const nativeResponseValue = wasm.TS_RandomBytes_as_EntropySource(this_arg);
58582 return nativeResponseValue;
58584 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
58586 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
58587 if(!isWasmInitialized) {
58588 throw new Error("initializeWasm() must be awaited first!");
58590 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
58591 // debug statements here
58593 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
58595 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
58596 if(!isWasmInitialized) {
58597 throw new Error("initializeWasm() must be awaited first!");
58599 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
58600 return nativeResponseValue;
58602 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
58604 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
58605 if(!isWasmInitialized) {
58606 throw new Error("initializeWasm() must be awaited first!");
58608 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
58609 return nativeResponseValue;
58611 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
58613 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
58614 if(!isWasmInitialized) {
58615 throw new Error("initializeWasm() must be awaited first!");
58617 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
58618 // debug statements here
58620 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
58622 export function OnionMessenger_free(this_obj: bigint): void {
58623 if(!isWasmInitialized) {
58624 throw new Error("initializeWasm() must be awaited first!");
58626 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
58627 // debug statements here
58629 // void MessageRouter_free(struct LDKMessageRouter this_ptr);
58631 export function MessageRouter_free(this_ptr: bigint): void {
58632 if(!isWasmInitialized) {
58633 throw new Error("initializeWasm() must be awaited first!");
58635 const nativeResponseValue = wasm.TS_MessageRouter_free(this_ptr);
58636 // debug statements here
58638 // void DefaultMessageRouter_free(struct LDKDefaultMessageRouter this_obj);
58640 export function DefaultMessageRouter_free(this_obj: bigint): void {
58641 if(!isWasmInitialized) {
58642 throw new Error("initializeWasm() must be awaited first!");
58644 const nativeResponseValue = wasm.TS_DefaultMessageRouter_free(this_obj);
58645 // debug statements here
58647 // MUST_USE_RES struct LDKDefaultMessageRouter DefaultMessageRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKEntropySource entropy_source);
58649 export function DefaultMessageRouter_new(network_graph: bigint, entropy_source: bigint): bigint {
58650 if(!isWasmInitialized) {
58651 throw new Error("initializeWasm() must be awaited first!");
58653 const nativeResponseValue = wasm.TS_DefaultMessageRouter_new(network_graph, entropy_source);
58654 return nativeResponseValue;
58656 // struct LDKMessageRouter DefaultMessageRouter_as_MessageRouter(const struct LDKDefaultMessageRouter *NONNULL_PTR this_arg);
58658 export function DefaultMessageRouter_as_MessageRouter(this_arg: bigint): bigint {
58659 if(!isWasmInitialized) {
58660 throw new Error("initializeWasm() must be awaited first!");
58662 const nativeResponseValue = wasm.TS_DefaultMessageRouter_as_MessageRouter(this_arg);
58663 return nativeResponseValue;
58665 // void OnionMessagePath_free(struct LDKOnionMessagePath this_obj);
58667 export function OnionMessagePath_free(this_obj: bigint): void {
58668 if(!isWasmInitialized) {
58669 throw new Error("initializeWasm() must be awaited first!");
58671 const nativeResponseValue = wasm.TS_OnionMessagePath_free(this_obj);
58672 // debug statements here
58674 // struct LDKCVec_PublicKeyZ OnionMessagePath_get_intermediate_nodes(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
58676 export function OnionMessagePath_get_intermediate_nodes(this_ptr: bigint): number {
58677 if(!isWasmInitialized) {
58678 throw new Error("initializeWasm() must be awaited first!");
58680 const nativeResponseValue = wasm.TS_OnionMessagePath_get_intermediate_nodes(this_ptr);
58681 return nativeResponseValue;
58683 // void OnionMessagePath_set_intermediate_nodes(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCVec_PublicKeyZ val);
58685 export function OnionMessagePath_set_intermediate_nodes(this_ptr: bigint, val: number): void {
58686 if(!isWasmInitialized) {
58687 throw new Error("initializeWasm() must be awaited first!");
58689 const nativeResponseValue = wasm.TS_OnionMessagePath_set_intermediate_nodes(this_ptr, val);
58690 // debug statements here
58692 // struct LDKDestination OnionMessagePath_get_destination(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
58694 export function OnionMessagePath_get_destination(this_ptr: bigint): bigint {
58695 if(!isWasmInitialized) {
58696 throw new Error("initializeWasm() must be awaited first!");
58698 const nativeResponseValue = wasm.TS_OnionMessagePath_get_destination(this_ptr);
58699 return nativeResponseValue;
58701 // void OnionMessagePath_set_destination(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKDestination val);
58703 export function OnionMessagePath_set_destination(this_ptr: bigint, val: bigint): void {
58704 if(!isWasmInitialized) {
58705 throw new Error("initializeWasm() must be awaited first!");
58707 const nativeResponseValue = wasm.TS_OnionMessagePath_set_destination(this_ptr, val);
58708 // debug statements here
58710 // struct LDKCOption_CVec_SocketAddressZZ OnionMessagePath_get_first_node_addresses(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
58712 export function OnionMessagePath_get_first_node_addresses(this_ptr: bigint): bigint {
58713 if(!isWasmInitialized) {
58714 throw new Error("initializeWasm() must be awaited first!");
58716 const nativeResponseValue = wasm.TS_OnionMessagePath_get_first_node_addresses(this_ptr);
58717 return nativeResponseValue;
58719 // void OnionMessagePath_set_first_node_addresses(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCOption_CVec_SocketAddressZZ val);
58721 export function OnionMessagePath_set_first_node_addresses(this_ptr: bigint, val: bigint): void {
58722 if(!isWasmInitialized) {
58723 throw new Error("initializeWasm() must be awaited first!");
58725 const nativeResponseValue = wasm.TS_OnionMessagePath_set_first_node_addresses(this_ptr, val);
58726 // debug statements here
58728 // MUST_USE_RES struct LDKOnionMessagePath OnionMessagePath_new(struct LDKCVec_PublicKeyZ intermediate_nodes_arg, struct LDKDestination destination_arg, struct LDKCOption_CVec_SocketAddressZZ first_node_addresses_arg);
58730 export function OnionMessagePath_new(intermediate_nodes_arg: number, destination_arg: bigint, first_node_addresses_arg: bigint): bigint {
58731 if(!isWasmInitialized) {
58732 throw new Error("initializeWasm() must be awaited first!");
58734 const nativeResponseValue = wasm.TS_OnionMessagePath_new(intermediate_nodes_arg, destination_arg, first_node_addresses_arg);
58735 return nativeResponseValue;
58737 // uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg);
58739 export function OnionMessagePath_clone_ptr(arg: bigint): bigint {
58740 if(!isWasmInitialized) {
58741 throw new Error("initializeWasm() must be awaited first!");
58743 const nativeResponseValue = wasm.TS_OnionMessagePath_clone_ptr(arg);
58744 return nativeResponseValue;
58746 // struct LDKOnionMessagePath OnionMessagePath_clone(const struct LDKOnionMessagePath *NONNULL_PTR orig);
58748 export function OnionMessagePath_clone(orig: bigint): bigint {
58749 if(!isWasmInitialized) {
58750 throw new Error("initializeWasm() must be awaited first!");
58752 const nativeResponseValue = wasm.TS_OnionMessagePath_clone(orig);
58753 return nativeResponseValue;
58755 // MUST_USE_RES struct LDKPublicKey OnionMessagePath_first_node(const struct LDKOnionMessagePath *NONNULL_PTR this_arg);
58757 export function OnionMessagePath_first_node(this_arg: bigint): number {
58758 if(!isWasmInitialized) {
58759 throw new Error("initializeWasm() must be awaited first!");
58761 const nativeResponseValue = wasm.TS_OnionMessagePath_first_node(this_arg);
58762 return nativeResponseValue;
58764 // void Destination_free(struct LDKDestination this_ptr);
58766 export function Destination_free(this_ptr: bigint): void {
58767 if(!isWasmInitialized) {
58768 throw new Error("initializeWasm() must be awaited first!");
58770 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
58771 // debug statements here
58773 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
58775 export function Destination_clone_ptr(arg: bigint): bigint {
58776 if(!isWasmInitialized) {
58777 throw new Error("initializeWasm() must be awaited first!");
58779 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
58780 return nativeResponseValue;
58782 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
58784 export function Destination_clone(orig: bigint): bigint {
58785 if(!isWasmInitialized) {
58786 throw new Error("initializeWasm() must be awaited first!");
58788 const nativeResponseValue = wasm.TS_Destination_clone(orig);
58789 return nativeResponseValue;
58791 // struct LDKDestination Destination_node(struct LDKPublicKey a);
58793 export function Destination_node(a: number): bigint {
58794 if(!isWasmInitialized) {
58795 throw new Error("initializeWasm() must be awaited first!");
58797 const nativeResponseValue = wasm.TS_Destination_node(a);
58798 return nativeResponseValue;
58800 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
58802 export function Destination_blinded_path(a: bigint): bigint {
58803 if(!isWasmInitialized) {
58804 throw new Error("initializeWasm() must be awaited first!");
58806 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
58807 return nativeResponseValue;
58809 // uint64_t Destination_hash(const struct LDKDestination *NONNULL_PTR o);
58811 export function Destination_hash(o: bigint): bigint {
58812 if(!isWasmInitialized) {
58813 throw new Error("initializeWasm() must be awaited first!");
58815 const nativeResponseValue = wasm.TS_Destination_hash(o);
58816 return nativeResponseValue;
58818 // bool Destination_eq(const struct LDKDestination *NONNULL_PTR a, const struct LDKDestination *NONNULL_PTR b);
58820 export function Destination_eq(a: bigint, b: bigint): boolean {
58821 if(!isWasmInitialized) {
58822 throw new Error("initializeWasm() must be awaited first!");
58824 const nativeResponseValue = wasm.TS_Destination_eq(a, b);
58825 return nativeResponseValue;
58827 // void Destination_resolve(struct LDKDestination *NONNULL_PTR this_arg, const struct LDKReadOnlyNetworkGraph *NONNULL_PTR network_graph);
58829 export function Destination_resolve(this_arg: bigint, network_graph: bigint): void {
58830 if(!isWasmInitialized) {
58831 throw new Error("initializeWasm() must be awaited first!");
58833 const nativeResponseValue = wasm.TS_Destination_resolve(this_arg, network_graph);
58834 // debug statements here
58836 // void SendSuccess_free(struct LDKSendSuccess this_ptr);
58838 export function SendSuccess_free(this_ptr: bigint): void {
58839 if(!isWasmInitialized) {
58840 throw new Error("initializeWasm() must be awaited first!");
58842 const nativeResponseValue = wasm.TS_SendSuccess_free(this_ptr);
58843 // debug statements here
58845 // uint64_t SendSuccess_clone_ptr(LDKSendSuccess *NONNULL_PTR arg);
58847 export function SendSuccess_clone_ptr(arg: bigint): bigint {
58848 if(!isWasmInitialized) {
58849 throw new Error("initializeWasm() must be awaited first!");
58851 const nativeResponseValue = wasm.TS_SendSuccess_clone_ptr(arg);
58852 return nativeResponseValue;
58854 // struct LDKSendSuccess SendSuccess_clone(const struct LDKSendSuccess *NONNULL_PTR orig);
58856 export function SendSuccess_clone(orig: bigint): bigint {
58857 if(!isWasmInitialized) {
58858 throw new Error("initializeWasm() must be awaited first!");
58860 const nativeResponseValue = wasm.TS_SendSuccess_clone(orig);
58861 return nativeResponseValue;
58863 // struct LDKSendSuccess SendSuccess_buffered(void);
58865 export function SendSuccess_buffered(): bigint {
58866 if(!isWasmInitialized) {
58867 throw new Error("initializeWasm() must be awaited first!");
58869 const nativeResponseValue = wasm.TS_SendSuccess_buffered();
58870 return nativeResponseValue;
58872 // struct LDKSendSuccess SendSuccess_buffered_awaiting_connection(struct LDKPublicKey a);
58874 export function SendSuccess_buffered_awaiting_connection(a: number): bigint {
58875 if(!isWasmInitialized) {
58876 throw new Error("initializeWasm() must be awaited first!");
58878 const nativeResponseValue = wasm.TS_SendSuccess_buffered_awaiting_connection(a);
58879 return nativeResponseValue;
58881 // uint64_t SendSuccess_hash(const struct LDKSendSuccess *NONNULL_PTR o);
58883 export function SendSuccess_hash(o: bigint): bigint {
58884 if(!isWasmInitialized) {
58885 throw new Error("initializeWasm() must be awaited first!");
58887 const nativeResponseValue = wasm.TS_SendSuccess_hash(o);
58888 return nativeResponseValue;
58890 // bool SendSuccess_eq(const struct LDKSendSuccess *NONNULL_PTR a, const struct LDKSendSuccess *NONNULL_PTR b);
58892 export function SendSuccess_eq(a: bigint, b: bigint): boolean {
58893 if(!isWasmInitialized) {
58894 throw new Error("initializeWasm() must be awaited first!");
58896 const nativeResponseValue = wasm.TS_SendSuccess_eq(a, b);
58897 return nativeResponseValue;
58899 // void SendError_free(struct LDKSendError this_ptr);
58901 export function SendError_free(this_ptr: bigint): void {
58902 if(!isWasmInitialized) {
58903 throw new Error("initializeWasm() must be awaited first!");
58905 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
58906 // debug statements here
58908 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
58910 export function SendError_clone_ptr(arg: bigint): bigint {
58911 if(!isWasmInitialized) {
58912 throw new Error("initializeWasm() must be awaited first!");
58914 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
58915 return nativeResponseValue;
58917 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
58919 export function SendError_clone(orig: bigint): bigint {
58920 if(!isWasmInitialized) {
58921 throw new Error("initializeWasm() must be awaited first!");
58923 const nativeResponseValue = wasm.TS_SendError_clone(orig);
58924 return nativeResponseValue;
58926 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
58928 export function SendError_secp256k1(a: Secp256k1Error): bigint {
58929 if(!isWasmInitialized) {
58930 throw new Error("initializeWasm() must be awaited first!");
58932 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
58933 return nativeResponseValue;
58935 // struct LDKSendError SendError_too_big_packet(void);
58937 export function SendError_too_big_packet(): bigint {
58938 if(!isWasmInitialized) {
58939 throw new Error("initializeWasm() must be awaited first!");
58941 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
58942 return nativeResponseValue;
58944 // struct LDKSendError SendError_too_few_blinded_hops(void);
58946 export function SendError_too_few_blinded_hops(): bigint {
58947 if(!isWasmInitialized) {
58948 throw new Error("initializeWasm() must be awaited first!");
58950 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
58951 return nativeResponseValue;
58953 // struct LDKSendError SendError_invalid_first_hop(struct LDKPublicKey a);
58955 export function SendError_invalid_first_hop(a: number): bigint {
58956 if(!isWasmInitialized) {
58957 throw new Error("initializeWasm() must be awaited first!");
58959 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop(a);
58960 return nativeResponseValue;
58962 // struct LDKSendError SendError_path_not_found(void);
58964 export function SendError_path_not_found(): bigint {
58965 if(!isWasmInitialized) {
58966 throw new Error("initializeWasm() must be awaited first!");
58968 const nativeResponseValue = wasm.TS_SendError_path_not_found();
58969 return nativeResponseValue;
58971 // struct LDKSendError SendError_invalid_message(void);
58973 export function SendError_invalid_message(): bigint {
58974 if(!isWasmInitialized) {
58975 throw new Error("initializeWasm() must be awaited first!");
58977 const nativeResponseValue = wasm.TS_SendError_invalid_message();
58978 return nativeResponseValue;
58980 // struct LDKSendError SendError_buffer_full(void);
58982 export function SendError_buffer_full(): bigint {
58983 if(!isWasmInitialized) {
58984 throw new Error("initializeWasm() must be awaited first!");
58986 const nativeResponseValue = wasm.TS_SendError_buffer_full();
58987 return nativeResponseValue;
58989 // struct LDKSendError SendError_get_node_id_failed(void);
58991 export function SendError_get_node_id_failed(): bigint {
58992 if(!isWasmInitialized) {
58993 throw new Error("initializeWasm() must be awaited first!");
58995 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
58996 return nativeResponseValue;
58998 // struct LDKSendError SendError_unresolved_introduction_node(void);
59000 export function SendError_unresolved_introduction_node(): bigint {
59001 if(!isWasmInitialized) {
59002 throw new Error("initializeWasm() must be awaited first!");
59004 const nativeResponseValue = wasm.TS_SendError_unresolved_introduction_node();
59005 return nativeResponseValue;
59007 // struct LDKSendError SendError_blinded_path_advance_failed(void);
59009 export function SendError_blinded_path_advance_failed(): bigint {
59010 if(!isWasmInitialized) {
59011 throw new Error("initializeWasm() must be awaited first!");
59013 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
59014 return nativeResponseValue;
59016 // uint64_t SendError_hash(const struct LDKSendError *NONNULL_PTR o);
59018 export function SendError_hash(o: bigint): bigint {
59019 if(!isWasmInitialized) {
59020 throw new Error("initializeWasm() must be awaited first!");
59022 const nativeResponseValue = wasm.TS_SendError_hash(o);
59023 return nativeResponseValue;
59025 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
59027 export function SendError_eq(a: bigint, b: bigint): boolean {
59028 if(!isWasmInitialized) {
59029 throw new Error("initializeWasm() must be awaited first!");
59031 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
59032 return nativeResponseValue;
59034 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
59036 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
59037 if(!isWasmInitialized) {
59038 throw new Error("initializeWasm() must be awaited first!");
59040 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
59041 // debug statements here
59043 // void PeeledOnion_free(struct LDKPeeledOnion this_ptr);
59045 export function PeeledOnion_free(this_ptr: bigint): void {
59046 if(!isWasmInitialized) {
59047 throw new Error("initializeWasm() must be awaited first!");
59049 const nativeResponseValue = wasm.TS_PeeledOnion_free(this_ptr);
59050 // debug statements here
59052 // uint64_t PeeledOnion_clone_ptr(LDKPeeledOnion *NONNULL_PTR arg);
59054 export function PeeledOnion_clone_ptr(arg: bigint): bigint {
59055 if(!isWasmInitialized) {
59056 throw new Error("initializeWasm() must be awaited first!");
59058 const nativeResponseValue = wasm.TS_PeeledOnion_clone_ptr(arg);
59059 return nativeResponseValue;
59061 // struct LDKPeeledOnion PeeledOnion_clone(const struct LDKPeeledOnion *NONNULL_PTR orig);
59063 export function PeeledOnion_clone(orig: bigint): bigint {
59064 if(!isWasmInitialized) {
59065 throw new Error("initializeWasm() must be awaited first!");
59067 const nativeResponseValue = wasm.TS_PeeledOnion_clone(orig);
59068 return nativeResponseValue;
59070 // struct LDKPeeledOnion PeeledOnion_forward(struct LDKNextMessageHop a, struct LDKOnionMessage b);
59072 export function PeeledOnion_forward(a: bigint, b: bigint): bigint {
59073 if(!isWasmInitialized) {
59074 throw new Error("initializeWasm() must be awaited first!");
59076 const nativeResponseValue = wasm.TS_PeeledOnion_forward(a, b);
59077 return nativeResponseValue;
59079 // struct LDKPeeledOnion PeeledOnion_receive(struct LDKParsedOnionMessageContents a, struct LDKThirtyTwoBytes b, struct LDKBlindedPath c);
59081 export function PeeledOnion_receive(a: bigint, b: number, c: bigint): bigint {
59082 if(!isWasmInitialized) {
59083 throw new Error("initializeWasm() must be awaited first!");
59085 const nativeResponseValue = wasm.TS_PeeledOnion_receive(a, b, c);
59086 return nativeResponseValue;
59088 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ create_onion_message_resolving_destination(const struct LDKEntropySource *NONNULL_PTR entropy_source, const struct LDKNodeSigner *NONNULL_PTR node_signer, const struct LDKNodeIdLookUp *NONNULL_PTR node_id_lookup, const struct LDKReadOnlyNetworkGraph *NONNULL_PTR network_graph, struct LDKOnionMessagePath path, struct LDKOnionMessageContents contents, struct LDKBlindedPath reply_path);
59090 export function create_onion_message_resolving_destination(entropy_source: bigint, node_signer: bigint, node_id_lookup: bigint, network_graph: bigint, path: bigint, contents: bigint, reply_path: bigint): bigint {
59091 if(!isWasmInitialized) {
59092 throw new Error("initializeWasm() must be awaited first!");
59094 const nativeResponseValue = wasm.TS_create_onion_message_resolving_destination(entropy_source, node_signer, node_id_lookup, network_graph, path, contents, reply_path);
59095 return nativeResponseValue;
59097 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ create_onion_message(const struct LDKEntropySource *NONNULL_PTR entropy_source, const struct LDKNodeSigner *NONNULL_PTR node_signer, const struct LDKNodeIdLookUp *NONNULL_PTR node_id_lookup, struct LDKOnionMessagePath path, struct LDKOnionMessageContents contents, struct LDKBlindedPath reply_path);
59099 export function create_onion_message(entropy_source: bigint, node_signer: bigint, node_id_lookup: bigint, path: bigint, contents: bigint, reply_path: bigint): bigint {
59100 if(!isWasmInitialized) {
59101 throw new Error("initializeWasm() must be awaited first!");
59103 const nativeResponseValue = wasm.TS_create_onion_message(entropy_source, node_signer, node_id_lookup, path, contents, reply_path);
59104 return nativeResponseValue;
59106 // struct LDKCResult_PeeledOnionNoneZ peel_onion_message(const struct LDKOnionMessage *NONNULL_PTR msg, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
59108 export function peel_onion_message(msg: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
59109 if(!isWasmInitialized) {
59110 throw new Error("initializeWasm() must be awaited first!");
59112 const nativeResponseValue = wasm.TS_peel_onion_message(msg, node_signer, logger, custom_handler);
59113 return nativeResponseValue;
59115 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKNodeIdLookUp node_id_lookup, struct LDKMessageRouter message_router, struct LDKOffersMessageHandler offers_handler, struct LDKCustomOnionMessageHandler custom_handler);
59117 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, node_id_lookup: bigint, message_router: bigint, offers_handler: bigint, custom_handler: bigint): bigint {
59118 if(!isWasmInitialized) {
59119 throw new Error("initializeWasm() must be awaited first!");
59121 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, node_id_lookup, message_router, offers_handler, custom_handler);
59122 return nativeResponseValue;
59124 // MUST_USE_RES struct LDKCResult_SendSuccessSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKOnionMessageContents contents, struct LDKDestination destination, struct LDKBlindedPath reply_path);
59126 export function OnionMessenger_send_onion_message(this_arg: bigint, contents: bigint, destination: bigint, reply_path: bigint): bigint {
59127 if(!isWasmInitialized) {
59128 throw new Error("initializeWasm() must be awaited first!");
59130 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, contents, destination, reply_path);
59131 return nativeResponseValue;
59133 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
59135 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
59136 if(!isWasmInitialized) {
59137 throw new Error("initializeWasm() must be awaited first!");
59139 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
59140 return nativeResponseValue;
59142 // void OffersMessageHandler_free(struct LDKOffersMessageHandler this_ptr);
59144 export function OffersMessageHandler_free(this_ptr: bigint): void {
59145 if(!isWasmInitialized) {
59146 throw new Error("initializeWasm() must be awaited first!");
59148 const nativeResponseValue = wasm.TS_OffersMessageHandler_free(this_ptr);
59149 // debug statements here
59151 // void OffersMessage_free(struct LDKOffersMessage this_ptr);
59153 export function OffersMessage_free(this_ptr: bigint): void {
59154 if(!isWasmInitialized) {
59155 throw new Error("initializeWasm() must be awaited first!");
59157 const nativeResponseValue = wasm.TS_OffersMessage_free(this_ptr);
59158 // debug statements here
59160 // uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg);
59162 export function OffersMessage_clone_ptr(arg: bigint): bigint {
59163 if(!isWasmInitialized) {
59164 throw new Error("initializeWasm() must be awaited first!");
59166 const nativeResponseValue = wasm.TS_OffersMessage_clone_ptr(arg);
59167 return nativeResponseValue;
59169 // struct LDKOffersMessage OffersMessage_clone(const struct LDKOffersMessage *NONNULL_PTR orig);
59171 export function OffersMessage_clone(orig: bigint): bigint {
59172 if(!isWasmInitialized) {
59173 throw new Error("initializeWasm() must be awaited first!");
59175 const nativeResponseValue = wasm.TS_OffersMessage_clone(orig);
59176 return nativeResponseValue;
59178 // struct LDKOffersMessage OffersMessage_invoice_request(struct LDKInvoiceRequest a);
59180 export function OffersMessage_invoice_request(a: bigint): bigint {
59181 if(!isWasmInitialized) {
59182 throw new Error("initializeWasm() must be awaited first!");
59184 const nativeResponseValue = wasm.TS_OffersMessage_invoice_request(a);
59185 return nativeResponseValue;
59187 // struct LDKOffersMessage OffersMessage_invoice(struct LDKBolt12Invoice a);
59189 export function OffersMessage_invoice(a: bigint): bigint {
59190 if(!isWasmInitialized) {
59191 throw new Error("initializeWasm() must be awaited first!");
59193 const nativeResponseValue = wasm.TS_OffersMessage_invoice(a);
59194 return nativeResponseValue;
59196 // struct LDKOffersMessage OffersMessage_invoice_error(struct LDKInvoiceError a);
59198 export function OffersMessage_invoice_error(a: bigint): bigint {
59199 if(!isWasmInitialized) {
59200 throw new Error("initializeWasm() must be awaited first!");
59202 const nativeResponseValue = wasm.TS_OffersMessage_invoice_error(a);
59203 return nativeResponseValue;
59205 // MUST_USE_RES bool OffersMessage_is_known_type(uint64_t tlv_type);
59207 export function OffersMessage_is_known_type(tlv_type: bigint): boolean {
59208 if(!isWasmInitialized) {
59209 throw new Error("initializeWasm() must be awaited first!");
59211 const nativeResponseValue = wasm.TS_OffersMessage_is_known_type(tlv_type);
59212 return nativeResponseValue;
59214 // struct LDKOnionMessageContents OffersMessage_as_OnionMessageContents(const struct LDKOffersMessage *NONNULL_PTR this_arg);
59216 export function OffersMessage_as_OnionMessageContents(this_arg: bigint): bigint {
59217 if(!isWasmInitialized) {
59218 throw new Error("initializeWasm() must be awaited first!");
59220 const nativeResponseValue = wasm.TS_OffersMessage_as_OnionMessageContents(this_arg);
59221 return nativeResponseValue;
59223 // struct LDKCVec_u8Z OffersMessage_write(const struct LDKOffersMessage *NONNULL_PTR obj);
59225 export function OffersMessage_write(obj: bigint): number {
59226 if(!isWasmInitialized) {
59227 throw new Error("initializeWasm() must be awaited first!");
59229 const nativeResponseValue = wasm.TS_OffersMessage_write(obj);
59230 return nativeResponseValue;
59232 // struct LDKCResult_OffersMessageDecodeErrorZ OffersMessage_read(struct LDKu8slice ser, uint64_t arg_a, const struct LDKLogger *NONNULL_PTR arg_b);
59234 export function OffersMessage_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
59235 if(!isWasmInitialized) {
59236 throw new Error("initializeWasm() must be awaited first!");
59238 const nativeResponseValue = wasm.TS_OffersMessage_read(ser, arg_a, arg_b);
59239 return nativeResponseValue;
59241 // void Packet_free(struct LDKPacket this_obj);
59243 export function Packet_free(this_obj: bigint): void {
59244 if(!isWasmInitialized) {
59245 throw new Error("initializeWasm() must be awaited first!");
59247 const nativeResponseValue = wasm.TS_Packet_free(this_obj);
59248 // debug statements here
59250 // uint8_t Packet_get_version(const struct LDKPacket *NONNULL_PTR this_ptr);
59252 export function Packet_get_version(this_ptr: bigint): number {
59253 if(!isWasmInitialized) {
59254 throw new Error("initializeWasm() must be awaited first!");
59256 const nativeResponseValue = wasm.TS_Packet_get_version(this_ptr);
59257 return nativeResponseValue;
59259 // void Packet_set_version(struct LDKPacket *NONNULL_PTR this_ptr, uint8_t val);
59261 export function Packet_set_version(this_ptr: bigint, val: number): void {
59262 if(!isWasmInitialized) {
59263 throw new Error("initializeWasm() must be awaited first!");
59265 const nativeResponseValue = wasm.TS_Packet_set_version(this_ptr, val);
59266 // debug statements here
59268 // struct LDKPublicKey Packet_get_public_key(const struct LDKPacket *NONNULL_PTR this_ptr);
59270 export function Packet_get_public_key(this_ptr: bigint): number {
59271 if(!isWasmInitialized) {
59272 throw new Error("initializeWasm() must be awaited first!");
59274 const nativeResponseValue = wasm.TS_Packet_get_public_key(this_ptr);
59275 return nativeResponseValue;
59277 // void Packet_set_public_key(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKPublicKey val);
59279 export function Packet_set_public_key(this_ptr: bigint, val: number): void {
59280 if(!isWasmInitialized) {
59281 throw new Error("initializeWasm() must be awaited first!");
59283 const nativeResponseValue = wasm.TS_Packet_set_public_key(this_ptr, val);
59284 // debug statements here
59286 // struct LDKCVec_u8Z Packet_get_hop_data(const struct LDKPacket *NONNULL_PTR this_ptr);
59288 export function Packet_get_hop_data(this_ptr: bigint): number {
59289 if(!isWasmInitialized) {
59290 throw new Error("initializeWasm() must be awaited first!");
59292 const nativeResponseValue = wasm.TS_Packet_get_hop_data(this_ptr);
59293 return nativeResponseValue;
59295 // void Packet_set_hop_data(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
59297 export function Packet_set_hop_data(this_ptr: bigint, val: number): void {
59298 if(!isWasmInitialized) {
59299 throw new Error("initializeWasm() must be awaited first!");
59301 const nativeResponseValue = wasm.TS_Packet_set_hop_data(this_ptr, val);
59302 // debug statements here
59304 // const uint8_t (*Packet_get_hmac(const struct LDKPacket *NONNULL_PTR this_ptr))[32];
59306 export function Packet_get_hmac(this_ptr: bigint): number {
59307 if(!isWasmInitialized) {
59308 throw new Error("initializeWasm() must be awaited first!");
59310 const nativeResponseValue = wasm.TS_Packet_get_hmac(this_ptr);
59311 return nativeResponseValue;
59313 // void Packet_set_hmac(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
59315 export function Packet_set_hmac(this_ptr: bigint, val: number): void {
59316 if(!isWasmInitialized) {
59317 throw new Error("initializeWasm() must be awaited first!");
59319 const nativeResponseValue = wasm.TS_Packet_set_hmac(this_ptr, val);
59320 // debug statements here
59322 // MUST_USE_RES struct LDKPacket Packet_new(uint8_t version_arg, struct LDKPublicKey public_key_arg, struct LDKCVec_u8Z hop_data_arg, struct LDKThirtyTwoBytes hmac_arg);
59324 export function Packet_new(version_arg: number, public_key_arg: number, hop_data_arg: number, hmac_arg: number): bigint {
59325 if(!isWasmInitialized) {
59326 throw new Error("initializeWasm() must be awaited first!");
59328 const nativeResponseValue = wasm.TS_Packet_new(version_arg, public_key_arg, hop_data_arg, hmac_arg);
59329 return nativeResponseValue;
59331 // uint64_t Packet_clone_ptr(LDKPacket *NONNULL_PTR arg);
59333 export function Packet_clone_ptr(arg: bigint): bigint {
59334 if(!isWasmInitialized) {
59335 throw new Error("initializeWasm() must be awaited first!");
59337 const nativeResponseValue = wasm.TS_Packet_clone_ptr(arg);
59338 return nativeResponseValue;
59340 // struct LDKPacket Packet_clone(const struct LDKPacket *NONNULL_PTR orig);
59342 export function Packet_clone(orig: bigint): bigint {
59343 if(!isWasmInitialized) {
59344 throw new Error("initializeWasm() must be awaited first!");
59346 const nativeResponseValue = wasm.TS_Packet_clone(orig);
59347 return nativeResponseValue;
59349 // uint64_t Packet_hash(const struct LDKPacket *NONNULL_PTR o);
59351 export function Packet_hash(o: bigint): bigint {
59352 if(!isWasmInitialized) {
59353 throw new Error("initializeWasm() must be awaited first!");
59355 const nativeResponseValue = wasm.TS_Packet_hash(o);
59356 return nativeResponseValue;
59358 // bool Packet_eq(const struct LDKPacket *NONNULL_PTR a, const struct LDKPacket *NONNULL_PTR b);
59360 export function Packet_eq(a: bigint, b: bigint): boolean {
59361 if(!isWasmInitialized) {
59362 throw new Error("initializeWasm() must be awaited first!");
59364 const nativeResponseValue = wasm.TS_Packet_eq(a, b);
59365 return nativeResponseValue;
59367 // struct LDKCVec_u8Z Packet_write(const struct LDKPacket *NONNULL_PTR obj);
59369 export function Packet_write(obj: bigint): number {
59370 if(!isWasmInitialized) {
59371 throw new Error("initializeWasm() must be awaited first!");
59373 const nativeResponseValue = wasm.TS_Packet_write(obj);
59374 return nativeResponseValue;
59376 // void ParsedOnionMessageContents_free(struct LDKParsedOnionMessageContents this_ptr);
59378 export function ParsedOnionMessageContents_free(this_ptr: bigint): void {
59379 if(!isWasmInitialized) {
59380 throw new Error("initializeWasm() must be awaited first!");
59382 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_free(this_ptr);
59383 // debug statements here
59385 // uint64_t ParsedOnionMessageContents_clone_ptr(LDKParsedOnionMessageContents *NONNULL_PTR arg);
59387 export function ParsedOnionMessageContents_clone_ptr(arg: bigint): bigint {
59388 if(!isWasmInitialized) {
59389 throw new Error("initializeWasm() must be awaited first!");
59391 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone_ptr(arg);
59392 return nativeResponseValue;
59394 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_clone(const struct LDKParsedOnionMessageContents *NONNULL_PTR orig);
59396 export function ParsedOnionMessageContents_clone(orig: bigint): bigint {
59397 if(!isWasmInitialized) {
59398 throw new Error("initializeWasm() must be awaited first!");
59400 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone(orig);
59401 return nativeResponseValue;
59403 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_offers(struct LDKOffersMessage a);
59405 export function ParsedOnionMessageContents_offers(a: bigint): bigint {
59406 if(!isWasmInitialized) {
59407 throw new Error("initializeWasm() must be awaited first!");
59409 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_offers(a);
59410 return nativeResponseValue;
59412 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_custom(struct LDKOnionMessageContents a);
59414 export function ParsedOnionMessageContents_custom(a: bigint): bigint {
59415 if(!isWasmInitialized) {
59416 throw new Error("initializeWasm() must be awaited first!");
59418 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_custom(a);
59419 return nativeResponseValue;
59421 // struct LDKOnionMessageContents ParsedOnionMessageContents_as_OnionMessageContents(const struct LDKParsedOnionMessageContents *NONNULL_PTR this_arg);
59423 export function ParsedOnionMessageContents_as_OnionMessageContents(this_arg: bigint): bigint {
59424 if(!isWasmInitialized) {
59425 throw new Error("initializeWasm() must be awaited first!");
59427 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_as_OnionMessageContents(this_arg);
59428 return nativeResponseValue;
59430 // struct LDKCVec_u8Z ParsedOnionMessageContents_write(const struct LDKParsedOnionMessageContents *NONNULL_PTR obj);
59432 export function ParsedOnionMessageContents_write(obj: bigint): number {
59433 if(!isWasmInitialized) {
59434 throw new Error("initializeWasm() must be awaited first!");
59436 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_write(obj);
59437 return nativeResponseValue;
59439 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
59441 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
59442 if(!isWasmInitialized) {
59443 throw new Error("initializeWasm() must be awaited first!");
59445 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
59446 return nativeResponseValue;
59448 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
59450 export function OnionMessageContents_clone(orig: bigint): bigint {
59451 if(!isWasmInitialized) {
59452 throw new Error("initializeWasm() must be awaited first!");
59454 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
59455 return nativeResponseValue;
59457 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
59459 export function OnionMessageContents_free(this_ptr: bigint): void {
59460 if(!isWasmInitialized) {
59461 throw new Error("initializeWasm() must be awaited first!");
59463 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
59464 // debug statements here
59466 // void NextMessageHop_free(struct LDKNextMessageHop this_ptr);
59468 export function NextMessageHop_free(this_ptr: bigint): void {
59469 if(!isWasmInitialized) {
59470 throw new Error("initializeWasm() must be awaited first!");
59472 const nativeResponseValue = wasm.TS_NextMessageHop_free(this_ptr);
59473 // debug statements here
59475 // uint64_t NextMessageHop_clone_ptr(LDKNextMessageHop *NONNULL_PTR arg);
59477 export function NextMessageHop_clone_ptr(arg: bigint): bigint {
59478 if(!isWasmInitialized) {
59479 throw new Error("initializeWasm() must be awaited first!");
59481 const nativeResponseValue = wasm.TS_NextMessageHop_clone_ptr(arg);
59482 return nativeResponseValue;
59484 // struct LDKNextMessageHop NextMessageHop_clone(const struct LDKNextMessageHop *NONNULL_PTR orig);
59486 export function NextMessageHop_clone(orig: bigint): bigint {
59487 if(!isWasmInitialized) {
59488 throw new Error("initializeWasm() must be awaited first!");
59490 const nativeResponseValue = wasm.TS_NextMessageHop_clone(orig);
59491 return nativeResponseValue;
59493 // struct LDKNextMessageHop NextMessageHop_node_id(struct LDKPublicKey a);
59495 export function NextMessageHop_node_id(a: number): bigint {
59496 if(!isWasmInitialized) {
59497 throw new Error("initializeWasm() must be awaited first!");
59499 const nativeResponseValue = wasm.TS_NextMessageHop_node_id(a);
59500 return nativeResponseValue;
59502 // struct LDKNextMessageHop NextMessageHop_short_channel_id(uint64_t a);
59504 export function NextMessageHop_short_channel_id(a: bigint): bigint {
59505 if(!isWasmInitialized) {
59506 throw new Error("initializeWasm() must be awaited first!");
59508 const nativeResponseValue = wasm.TS_NextMessageHop_short_channel_id(a);
59509 return nativeResponseValue;
59511 // uint64_t NextMessageHop_hash(const struct LDKNextMessageHop *NONNULL_PTR o);
59513 export function NextMessageHop_hash(o: bigint): bigint {
59514 if(!isWasmInitialized) {
59515 throw new Error("initializeWasm() must be awaited first!");
59517 const nativeResponseValue = wasm.TS_NextMessageHop_hash(o);
59518 return nativeResponseValue;
59520 // bool NextMessageHop_eq(const struct LDKNextMessageHop *NONNULL_PTR a, const struct LDKNextMessageHop *NONNULL_PTR b);
59522 export function NextMessageHop_eq(a: bigint, b: bigint): boolean {
59523 if(!isWasmInitialized) {
59524 throw new Error("initializeWasm() must be awaited first!");
59526 const nativeResponseValue = wasm.TS_NextMessageHop_eq(a, b);
59527 return nativeResponseValue;
59529 // void BlindedPath_free(struct LDKBlindedPath this_obj);
59531 export function BlindedPath_free(this_obj: bigint): void {
59532 if(!isWasmInitialized) {
59533 throw new Error("initializeWasm() must be awaited first!");
59535 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
59536 // debug statements here
59538 // struct LDKIntroductionNode BlindedPath_get_introduction_node(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
59540 export function BlindedPath_get_introduction_node(this_ptr: bigint): bigint {
59541 if(!isWasmInitialized) {
59542 throw new Error("initializeWasm() must be awaited first!");
59544 const nativeResponseValue = wasm.TS_BlindedPath_get_introduction_node(this_ptr);
59545 return nativeResponseValue;
59547 // void BlindedPath_set_introduction_node(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKIntroductionNode val);
59549 export function BlindedPath_set_introduction_node(this_ptr: bigint, val: bigint): void {
59550 if(!isWasmInitialized) {
59551 throw new Error("initializeWasm() must be awaited first!");
59553 const nativeResponseValue = wasm.TS_BlindedPath_set_introduction_node(this_ptr, val);
59554 // debug statements here
59556 // struct LDKPublicKey BlindedPath_get_blinding_point(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
59558 export function BlindedPath_get_blinding_point(this_ptr: bigint): number {
59559 if(!isWasmInitialized) {
59560 throw new Error("initializeWasm() must be awaited first!");
59562 const nativeResponseValue = wasm.TS_BlindedPath_get_blinding_point(this_ptr);
59563 return nativeResponseValue;
59565 // void BlindedPath_set_blinding_point(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
59567 export function BlindedPath_set_blinding_point(this_ptr: bigint, val: number): void {
59568 if(!isWasmInitialized) {
59569 throw new Error("initializeWasm() must be awaited first!");
59571 const nativeResponseValue = wasm.TS_BlindedPath_set_blinding_point(this_ptr, val);
59572 // debug statements here
59574 // struct LDKCVec_BlindedHopZ BlindedPath_get_blinded_hops(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
59576 export function BlindedPath_get_blinded_hops(this_ptr: bigint): number {
59577 if(!isWasmInitialized) {
59578 throw new Error("initializeWasm() must be awaited first!");
59580 const nativeResponseValue = wasm.TS_BlindedPath_get_blinded_hops(this_ptr);
59581 return nativeResponseValue;
59583 // void BlindedPath_set_blinded_hops(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
59585 export function BlindedPath_set_blinded_hops(this_ptr: bigint, val: number): void {
59586 if(!isWasmInitialized) {
59587 throw new Error("initializeWasm() must be awaited first!");
59589 const nativeResponseValue = wasm.TS_BlindedPath_set_blinded_hops(this_ptr, val);
59590 // debug statements here
59592 // MUST_USE_RES struct LDKBlindedPath BlindedPath_new(struct LDKIntroductionNode introduction_node_arg, struct LDKPublicKey blinding_point_arg, struct LDKCVec_BlindedHopZ blinded_hops_arg);
59594 export function BlindedPath_new(introduction_node_arg: bigint, blinding_point_arg: number, blinded_hops_arg: number): bigint {
59595 if(!isWasmInitialized) {
59596 throw new Error("initializeWasm() must be awaited first!");
59598 const nativeResponseValue = wasm.TS_BlindedPath_new(introduction_node_arg, blinding_point_arg, blinded_hops_arg);
59599 return nativeResponseValue;
59601 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
59603 export function BlindedPath_clone_ptr(arg: bigint): bigint {
59604 if(!isWasmInitialized) {
59605 throw new Error("initializeWasm() must be awaited first!");
59607 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
59608 return nativeResponseValue;
59610 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
59612 export function BlindedPath_clone(orig: bigint): bigint {
59613 if(!isWasmInitialized) {
59614 throw new Error("initializeWasm() must be awaited first!");
59616 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
59617 return nativeResponseValue;
59619 // uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
59621 export function BlindedPath_hash(o: bigint): bigint {
59622 if(!isWasmInitialized) {
59623 throw new Error("initializeWasm() must be awaited first!");
59625 const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
59626 return nativeResponseValue;
59628 // bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
59630 export function BlindedPath_eq(a: bigint, b: bigint): boolean {
59631 if(!isWasmInitialized) {
59632 throw new Error("initializeWasm() must be awaited first!");
59634 const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
59635 return nativeResponseValue;
59637 // void IntroductionNode_free(struct LDKIntroductionNode this_ptr);
59639 export function IntroductionNode_free(this_ptr: bigint): void {
59640 if(!isWasmInitialized) {
59641 throw new Error("initializeWasm() must be awaited first!");
59643 const nativeResponseValue = wasm.TS_IntroductionNode_free(this_ptr);
59644 // debug statements here
59646 // uint64_t IntroductionNode_clone_ptr(LDKIntroductionNode *NONNULL_PTR arg);
59648 export function IntroductionNode_clone_ptr(arg: bigint): bigint {
59649 if(!isWasmInitialized) {
59650 throw new Error("initializeWasm() must be awaited first!");
59652 const nativeResponseValue = wasm.TS_IntroductionNode_clone_ptr(arg);
59653 return nativeResponseValue;
59655 // struct LDKIntroductionNode IntroductionNode_clone(const struct LDKIntroductionNode *NONNULL_PTR orig);
59657 export function IntroductionNode_clone(orig: bigint): bigint {
59658 if(!isWasmInitialized) {
59659 throw new Error("initializeWasm() must be awaited first!");
59661 const nativeResponseValue = wasm.TS_IntroductionNode_clone(orig);
59662 return nativeResponseValue;
59664 // struct LDKIntroductionNode IntroductionNode_node_id(struct LDKPublicKey a);
59666 export function IntroductionNode_node_id(a: number): bigint {
59667 if(!isWasmInitialized) {
59668 throw new Error("initializeWasm() must be awaited first!");
59670 const nativeResponseValue = wasm.TS_IntroductionNode_node_id(a);
59671 return nativeResponseValue;
59673 // struct LDKIntroductionNode IntroductionNode_directed_short_channel_id(enum LDKDirection a, uint64_t b);
59675 export function IntroductionNode_directed_short_channel_id(a: Direction, b: bigint): bigint {
59676 if(!isWasmInitialized) {
59677 throw new Error("initializeWasm() must be awaited first!");
59679 const nativeResponseValue = wasm.TS_IntroductionNode_directed_short_channel_id(a, b);
59680 return nativeResponseValue;
59682 // uint64_t IntroductionNode_hash(const struct LDKIntroductionNode *NONNULL_PTR o);
59684 export function IntroductionNode_hash(o: bigint): bigint {
59685 if(!isWasmInitialized) {
59686 throw new Error("initializeWasm() must be awaited first!");
59688 const nativeResponseValue = wasm.TS_IntroductionNode_hash(o);
59689 return nativeResponseValue;
59691 // bool IntroductionNode_eq(const struct LDKIntroductionNode *NONNULL_PTR a, const struct LDKIntroductionNode *NONNULL_PTR b);
59693 export function IntroductionNode_eq(a: bigint, b: bigint): boolean {
59694 if(!isWasmInitialized) {
59695 throw new Error("initializeWasm() must be awaited first!");
59697 const nativeResponseValue = wasm.TS_IntroductionNode_eq(a, b);
59698 return nativeResponseValue;
59700 // enum LDKDirection Direction_clone(const enum LDKDirection *NONNULL_PTR orig);
59702 export function Direction_clone(orig: bigint): Direction {
59703 if(!isWasmInitialized) {
59704 throw new Error("initializeWasm() must be awaited first!");
59706 const nativeResponseValue = wasm.TS_Direction_clone(orig);
59707 return nativeResponseValue;
59709 // enum LDKDirection Direction_node_one(void);
59711 export function Direction_node_one(): Direction {
59712 if(!isWasmInitialized) {
59713 throw new Error("initializeWasm() must be awaited first!");
59715 const nativeResponseValue = wasm.TS_Direction_node_one();
59716 return nativeResponseValue;
59718 // enum LDKDirection Direction_node_two(void);
59720 export function Direction_node_two(): Direction {
59721 if(!isWasmInitialized) {
59722 throw new Error("initializeWasm() must be awaited first!");
59724 const nativeResponseValue = wasm.TS_Direction_node_two();
59725 return nativeResponseValue;
59727 // uint64_t Direction_hash(const enum LDKDirection *NONNULL_PTR o);
59729 export function Direction_hash(o: bigint): bigint {
59730 if(!isWasmInitialized) {
59731 throw new Error("initializeWasm() must be awaited first!");
59733 const nativeResponseValue = wasm.TS_Direction_hash(o);
59734 return nativeResponseValue;
59736 // bool Direction_eq(const enum LDKDirection *NONNULL_PTR a, const enum LDKDirection *NONNULL_PTR b);
59738 export function Direction_eq(a: bigint, b: bigint): boolean {
59739 if(!isWasmInitialized) {
59740 throw new Error("initializeWasm() must be awaited first!");
59742 const nativeResponseValue = wasm.TS_Direction_eq(a, b);
59743 return nativeResponseValue;
59745 // void NodeIdLookUp_free(struct LDKNodeIdLookUp this_ptr);
59747 export function NodeIdLookUp_free(this_ptr: bigint): void {
59748 if(!isWasmInitialized) {
59749 throw new Error("initializeWasm() must be awaited first!");
59751 const nativeResponseValue = wasm.TS_NodeIdLookUp_free(this_ptr);
59752 // debug statements here
59754 // void EmptyNodeIdLookUp_free(struct LDKEmptyNodeIdLookUp this_obj);
59756 export function EmptyNodeIdLookUp_free(this_obj: bigint): void {
59757 if(!isWasmInitialized) {
59758 throw new Error("initializeWasm() must be awaited first!");
59760 const nativeResponseValue = wasm.TS_EmptyNodeIdLookUp_free(this_obj);
59761 // debug statements here
59763 // MUST_USE_RES struct LDKEmptyNodeIdLookUp EmptyNodeIdLookUp_new(void);
59765 export function EmptyNodeIdLookUp_new(): bigint {
59766 if(!isWasmInitialized) {
59767 throw new Error("initializeWasm() must be awaited first!");
59769 const nativeResponseValue = wasm.TS_EmptyNodeIdLookUp_new();
59770 return nativeResponseValue;
59772 // struct LDKNodeIdLookUp EmptyNodeIdLookUp_as_NodeIdLookUp(const struct LDKEmptyNodeIdLookUp *NONNULL_PTR this_arg);
59774 export function EmptyNodeIdLookUp_as_NodeIdLookUp(this_arg: bigint): bigint {
59775 if(!isWasmInitialized) {
59776 throw new Error("initializeWasm() must be awaited first!");
59778 const nativeResponseValue = wasm.TS_EmptyNodeIdLookUp_as_NodeIdLookUp(this_arg);
59779 return nativeResponseValue;
59781 // void BlindedHop_free(struct LDKBlindedHop this_obj);
59783 export function BlindedHop_free(this_obj: bigint): void {
59784 if(!isWasmInitialized) {
59785 throw new Error("initializeWasm() must be awaited first!");
59787 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
59788 // debug statements here
59790 // struct LDKPublicKey BlindedHop_get_blinded_node_id(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
59792 export function BlindedHop_get_blinded_node_id(this_ptr: bigint): number {
59793 if(!isWasmInitialized) {
59794 throw new Error("initializeWasm() must be awaited first!");
59796 const nativeResponseValue = wasm.TS_BlindedHop_get_blinded_node_id(this_ptr);
59797 return nativeResponseValue;
59799 // void BlindedHop_set_blinded_node_id(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
59801 export function BlindedHop_set_blinded_node_id(this_ptr: bigint, val: number): void {
59802 if(!isWasmInitialized) {
59803 throw new Error("initializeWasm() must be awaited first!");
59805 const nativeResponseValue = wasm.TS_BlindedHop_set_blinded_node_id(this_ptr, val);
59806 // debug statements here
59808 // struct LDKCVec_u8Z BlindedHop_get_encrypted_payload(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
59810 export function BlindedHop_get_encrypted_payload(this_ptr: bigint): number {
59811 if(!isWasmInitialized) {
59812 throw new Error("initializeWasm() must be awaited first!");
59814 const nativeResponseValue = wasm.TS_BlindedHop_get_encrypted_payload(this_ptr);
59815 return nativeResponseValue;
59817 // void BlindedHop_set_encrypted_payload(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
59819 export function BlindedHop_set_encrypted_payload(this_ptr: bigint, val: number): void {
59820 if(!isWasmInitialized) {
59821 throw new Error("initializeWasm() must be awaited first!");
59823 const nativeResponseValue = wasm.TS_BlindedHop_set_encrypted_payload(this_ptr, val);
59824 // debug statements here
59826 // MUST_USE_RES struct LDKBlindedHop BlindedHop_new(struct LDKPublicKey blinded_node_id_arg, struct LDKCVec_u8Z encrypted_payload_arg);
59828 export function BlindedHop_new(blinded_node_id_arg: number, encrypted_payload_arg: number): bigint {
59829 if(!isWasmInitialized) {
59830 throw new Error("initializeWasm() must be awaited first!");
59832 const nativeResponseValue = wasm.TS_BlindedHop_new(blinded_node_id_arg, encrypted_payload_arg);
59833 return nativeResponseValue;
59835 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
59837 export function BlindedHop_clone_ptr(arg: bigint): bigint {
59838 if(!isWasmInitialized) {
59839 throw new Error("initializeWasm() must be awaited first!");
59841 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
59842 return nativeResponseValue;
59844 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
59846 export function BlindedHop_clone(orig: bigint): bigint {
59847 if(!isWasmInitialized) {
59848 throw new Error("initializeWasm() must be awaited first!");
59850 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
59851 return nativeResponseValue;
59853 // uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
59855 export function BlindedHop_hash(o: bigint): bigint {
59856 if(!isWasmInitialized) {
59857 throw new Error("initializeWasm() must be awaited first!");
59859 const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
59860 return nativeResponseValue;
59862 // bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
59864 export function BlindedHop_eq(a: bigint, b: bigint): boolean {
59865 if(!isWasmInitialized) {
59866 throw new Error("initializeWasm() must be awaited first!");
59868 const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
59869 return nativeResponseValue;
59871 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_one_hop_for_message(struct LDKPublicKey recipient_node_id, struct LDKEntropySource entropy_source);
59873 export function BlindedPath_one_hop_for_message(recipient_node_id: number, entropy_source: bigint): bigint {
59874 if(!isWasmInitialized) {
59875 throw new Error("initializeWasm() must be awaited first!");
59877 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_message(recipient_node_id, entropy_source);
59878 return nativeResponseValue;
59880 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, struct LDKEntropySource entropy_source);
59882 export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
59883 if(!isWasmInitialized) {
59884 throw new Error("initializeWasm() must be awaited first!");
59886 const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
59887 return nativeResponseValue;
59889 // MUST_USE_RES struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ BlindedPath_one_hop_for_payment(struct LDKPublicKey payee_node_id, struct LDKReceiveTlvs payee_tlvs, uint16_t min_final_cltv_expiry_delta, struct LDKEntropySource entropy_source);
59891 export function BlindedPath_one_hop_for_payment(payee_node_id: number, payee_tlvs: bigint, min_final_cltv_expiry_delta: number, entropy_source: bigint): bigint {
59892 if(!isWasmInitialized) {
59893 throw new Error("initializeWasm() must be awaited first!");
59895 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_payment(payee_node_id, payee_tlvs, min_final_cltv_expiry_delta, entropy_source);
59896 return nativeResponseValue;
59898 // MUST_USE_RES struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ BlindedPath_new_for_payment(struct LDKCVec_ForwardNodeZ intermediate_nodes, struct LDKPublicKey payee_node_id, struct LDKReceiveTlvs payee_tlvs, uint64_t htlc_maximum_msat, uint16_t min_final_cltv_expiry_delta, struct LDKEntropySource entropy_source);
59900 export function BlindedPath_new_for_payment(intermediate_nodes: number, payee_node_id: number, payee_tlvs: bigint, htlc_maximum_msat: bigint, min_final_cltv_expiry_delta: number, entropy_source: bigint): bigint {
59901 if(!isWasmInitialized) {
59902 throw new Error("initializeWasm() must be awaited first!");
59904 const nativeResponseValue = wasm.TS_BlindedPath_new_for_payment(intermediate_nodes, payee_node_id, payee_tlvs, htlc_maximum_msat, min_final_cltv_expiry_delta, entropy_source);
59905 return nativeResponseValue;
59907 // MUST_USE_RES struct LDKNodeId BlindedPath_public_introduction_node_id(const struct LDKBlindedPath *NONNULL_PTR this_arg, const struct LDKReadOnlyNetworkGraph *NONNULL_PTR network_graph);
59909 export function BlindedPath_public_introduction_node_id(this_arg: bigint, network_graph: bigint): bigint {
59910 if(!isWasmInitialized) {
59911 throw new Error("initializeWasm() must be awaited first!");
59913 const nativeResponseValue = wasm.TS_BlindedPath_public_introduction_node_id(this_arg, network_graph);
59914 return nativeResponseValue;
59916 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
59918 export function BlindedPath_write(obj: bigint): number {
59919 if(!isWasmInitialized) {
59920 throw new Error("initializeWasm() must be awaited first!");
59922 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
59923 return nativeResponseValue;
59925 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
59927 export function BlindedPath_read(ser: number): bigint {
59928 if(!isWasmInitialized) {
59929 throw new Error("initializeWasm() must be awaited first!");
59931 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
59932 return nativeResponseValue;
59934 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
59936 export function BlindedHop_write(obj: bigint): number {
59937 if(!isWasmInitialized) {
59938 throw new Error("initializeWasm() must be awaited first!");
59940 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
59941 return nativeResponseValue;
59943 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
59945 export function BlindedHop_read(ser: number): bigint {
59946 if(!isWasmInitialized) {
59947 throw new Error("initializeWasm() must be awaited first!");
59949 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
59950 return nativeResponseValue;
59952 // void ForwardNode_free(struct LDKForwardNode this_obj);
59954 export function ForwardNode_free(this_obj: bigint): void {
59955 if(!isWasmInitialized) {
59956 throw new Error("initializeWasm() must be awaited first!");
59958 const nativeResponseValue = wasm.TS_ForwardNode_free(this_obj);
59959 // debug statements here
59961 // struct LDKForwardTlvs ForwardNode_get_tlvs(const struct LDKForwardNode *NONNULL_PTR this_ptr);
59963 export function ForwardNode_get_tlvs(this_ptr: bigint): bigint {
59964 if(!isWasmInitialized) {
59965 throw new Error("initializeWasm() must be awaited first!");
59967 const nativeResponseValue = wasm.TS_ForwardNode_get_tlvs(this_ptr);
59968 return nativeResponseValue;
59970 // void ForwardNode_set_tlvs(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKForwardTlvs val);
59972 export function ForwardNode_set_tlvs(this_ptr: bigint, val: bigint): void {
59973 if(!isWasmInitialized) {
59974 throw new Error("initializeWasm() must be awaited first!");
59976 const nativeResponseValue = wasm.TS_ForwardNode_set_tlvs(this_ptr, val);
59977 // debug statements here
59979 // struct LDKPublicKey ForwardNode_get_node_id(const struct LDKForwardNode *NONNULL_PTR this_ptr);
59981 export function ForwardNode_get_node_id(this_ptr: bigint): number {
59982 if(!isWasmInitialized) {
59983 throw new Error("initializeWasm() must be awaited first!");
59985 const nativeResponseValue = wasm.TS_ForwardNode_get_node_id(this_ptr);
59986 return nativeResponseValue;
59988 // void ForwardNode_set_node_id(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKPublicKey val);
59990 export function ForwardNode_set_node_id(this_ptr: bigint, val: number): void {
59991 if(!isWasmInitialized) {
59992 throw new Error("initializeWasm() must be awaited first!");
59994 const nativeResponseValue = wasm.TS_ForwardNode_set_node_id(this_ptr, val);
59995 // debug statements here
59997 // uint64_t ForwardNode_get_htlc_maximum_msat(const struct LDKForwardNode *NONNULL_PTR this_ptr);
59999 export function ForwardNode_get_htlc_maximum_msat(this_ptr: bigint): bigint {
60000 if(!isWasmInitialized) {
60001 throw new Error("initializeWasm() must be awaited first!");
60003 const nativeResponseValue = wasm.TS_ForwardNode_get_htlc_maximum_msat(this_ptr);
60004 return nativeResponseValue;
60006 // void ForwardNode_set_htlc_maximum_msat(struct LDKForwardNode *NONNULL_PTR this_ptr, uint64_t val);
60008 export function ForwardNode_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
60009 if(!isWasmInitialized) {
60010 throw new Error("initializeWasm() must be awaited first!");
60012 const nativeResponseValue = wasm.TS_ForwardNode_set_htlc_maximum_msat(this_ptr, val);
60013 // debug statements here
60015 // MUST_USE_RES struct LDKForwardNode ForwardNode_new(struct LDKForwardTlvs tlvs_arg, struct LDKPublicKey node_id_arg, uint64_t htlc_maximum_msat_arg);
60017 export function ForwardNode_new(tlvs_arg: bigint, node_id_arg: number, htlc_maximum_msat_arg: bigint): bigint {
60018 if(!isWasmInitialized) {
60019 throw new Error("initializeWasm() must be awaited first!");
60021 const nativeResponseValue = wasm.TS_ForwardNode_new(tlvs_arg, node_id_arg, htlc_maximum_msat_arg);
60022 return nativeResponseValue;
60024 // uint64_t ForwardNode_clone_ptr(LDKForwardNode *NONNULL_PTR arg);
60026 export function ForwardNode_clone_ptr(arg: bigint): bigint {
60027 if(!isWasmInitialized) {
60028 throw new Error("initializeWasm() must be awaited first!");
60030 const nativeResponseValue = wasm.TS_ForwardNode_clone_ptr(arg);
60031 return nativeResponseValue;
60033 // struct LDKForwardNode ForwardNode_clone(const struct LDKForwardNode *NONNULL_PTR orig);
60035 export function ForwardNode_clone(orig: bigint): bigint {
60036 if(!isWasmInitialized) {
60037 throw new Error("initializeWasm() must be awaited first!");
60039 const nativeResponseValue = wasm.TS_ForwardNode_clone(orig);
60040 return nativeResponseValue;
60042 // void ForwardTlvs_free(struct LDKForwardTlvs this_obj);
60044 export function ForwardTlvs_free(this_obj: bigint): void {
60045 if(!isWasmInitialized) {
60046 throw new Error("initializeWasm() must be awaited first!");
60048 const nativeResponseValue = wasm.TS_ForwardTlvs_free(this_obj);
60049 // debug statements here
60051 // uint64_t ForwardTlvs_get_short_channel_id(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
60053 export function ForwardTlvs_get_short_channel_id(this_ptr: bigint): bigint {
60054 if(!isWasmInitialized) {
60055 throw new Error("initializeWasm() must be awaited first!");
60057 const nativeResponseValue = wasm.TS_ForwardTlvs_get_short_channel_id(this_ptr);
60058 return nativeResponseValue;
60060 // void ForwardTlvs_set_short_channel_id(struct LDKForwardTlvs *NONNULL_PTR this_ptr, uint64_t val);
60062 export function ForwardTlvs_set_short_channel_id(this_ptr: bigint, val: bigint): void {
60063 if(!isWasmInitialized) {
60064 throw new Error("initializeWasm() must be awaited first!");
60066 const nativeResponseValue = wasm.TS_ForwardTlvs_set_short_channel_id(this_ptr, val);
60067 // debug statements here
60069 // struct LDKPaymentRelay ForwardTlvs_get_payment_relay(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
60071 export function ForwardTlvs_get_payment_relay(this_ptr: bigint): bigint {
60072 if(!isWasmInitialized) {
60073 throw new Error("initializeWasm() must be awaited first!");
60075 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_relay(this_ptr);
60076 return nativeResponseValue;
60078 // void ForwardTlvs_set_payment_relay(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentRelay val);
60080 export function ForwardTlvs_set_payment_relay(this_ptr: bigint, val: bigint): void {
60081 if(!isWasmInitialized) {
60082 throw new Error("initializeWasm() must be awaited first!");
60084 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_relay(this_ptr, val);
60085 // debug statements here
60087 // struct LDKPaymentConstraints ForwardTlvs_get_payment_constraints(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
60089 export function ForwardTlvs_get_payment_constraints(this_ptr: bigint): bigint {
60090 if(!isWasmInitialized) {
60091 throw new Error("initializeWasm() must be awaited first!");
60093 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_constraints(this_ptr);
60094 return nativeResponseValue;
60096 // void ForwardTlvs_set_payment_constraints(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
60098 export function ForwardTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
60099 if(!isWasmInitialized) {
60100 throw new Error("initializeWasm() must be awaited first!");
60102 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_constraints(this_ptr, val);
60103 // debug statements here
60105 // struct LDKBlindedHopFeatures ForwardTlvs_get_features(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
60107 export function ForwardTlvs_get_features(this_ptr: bigint): bigint {
60108 if(!isWasmInitialized) {
60109 throw new Error("initializeWasm() must be awaited first!");
60111 const nativeResponseValue = wasm.TS_ForwardTlvs_get_features(this_ptr);
60112 return nativeResponseValue;
60114 // void ForwardTlvs_set_features(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
60116 export function ForwardTlvs_set_features(this_ptr: bigint, val: bigint): void {
60117 if(!isWasmInitialized) {
60118 throw new Error("initializeWasm() must be awaited first!");
60120 const nativeResponseValue = wasm.TS_ForwardTlvs_set_features(this_ptr, val);
60121 // debug statements here
60123 // MUST_USE_RES struct LDKForwardTlvs ForwardTlvs_new(uint64_t short_channel_id_arg, struct LDKPaymentRelay payment_relay_arg, struct LDKPaymentConstraints payment_constraints_arg, struct LDKBlindedHopFeatures features_arg);
60125 export function ForwardTlvs_new(short_channel_id_arg: bigint, payment_relay_arg: bigint, payment_constraints_arg: bigint, features_arg: bigint): bigint {
60126 if(!isWasmInitialized) {
60127 throw new Error("initializeWasm() must be awaited first!");
60129 const nativeResponseValue = wasm.TS_ForwardTlvs_new(short_channel_id_arg, payment_relay_arg, payment_constraints_arg, features_arg);
60130 return nativeResponseValue;
60132 // uint64_t ForwardTlvs_clone_ptr(LDKForwardTlvs *NONNULL_PTR arg);
60134 export function ForwardTlvs_clone_ptr(arg: bigint): bigint {
60135 if(!isWasmInitialized) {
60136 throw new Error("initializeWasm() must be awaited first!");
60138 const nativeResponseValue = wasm.TS_ForwardTlvs_clone_ptr(arg);
60139 return nativeResponseValue;
60141 // struct LDKForwardTlvs ForwardTlvs_clone(const struct LDKForwardTlvs *NONNULL_PTR orig);
60143 export function ForwardTlvs_clone(orig: bigint): bigint {
60144 if(!isWasmInitialized) {
60145 throw new Error("initializeWasm() must be awaited first!");
60147 const nativeResponseValue = wasm.TS_ForwardTlvs_clone(orig);
60148 return nativeResponseValue;
60150 // void ReceiveTlvs_free(struct LDKReceiveTlvs this_obj);
60152 export function ReceiveTlvs_free(this_obj: bigint): void {
60153 if(!isWasmInitialized) {
60154 throw new Error("initializeWasm() must be awaited first!");
60156 const nativeResponseValue = wasm.TS_ReceiveTlvs_free(this_obj);
60157 // debug statements here
60159 // const uint8_t (*ReceiveTlvs_get_payment_secret(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr))[32];
60161 export function ReceiveTlvs_get_payment_secret(this_ptr: bigint): number {
60162 if(!isWasmInitialized) {
60163 throw new Error("initializeWasm() must be awaited first!");
60165 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_secret(this_ptr);
60166 return nativeResponseValue;
60168 // void ReceiveTlvs_set_payment_secret(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
60170 export function ReceiveTlvs_set_payment_secret(this_ptr: bigint, val: number): void {
60171 if(!isWasmInitialized) {
60172 throw new Error("initializeWasm() must be awaited first!");
60174 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_secret(this_ptr, val);
60175 // debug statements here
60177 // struct LDKPaymentConstraints ReceiveTlvs_get_payment_constraints(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr);
60179 export function ReceiveTlvs_get_payment_constraints(this_ptr: bigint): bigint {
60180 if(!isWasmInitialized) {
60181 throw new Error("initializeWasm() must be awaited first!");
60183 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_constraints(this_ptr);
60184 return nativeResponseValue;
60186 // void ReceiveTlvs_set_payment_constraints(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
60188 export function ReceiveTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
60189 if(!isWasmInitialized) {
60190 throw new Error("initializeWasm() must be awaited first!");
60192 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_constraints(this_ptr, val);
60193 // debug statements here
60195 // struct LDKPaymentContext ReceiveTlvs_get_payment_context(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr);
60197 export function ReceiveTlvs_get_payment_context(this_ptr: bigint): bigint {
60198 if(!isWasmInitialized) {
60199 throw new Error("initializeWasm() must be awaited first!");
60201 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_context(this_ptr);
60202 return nativeResponseValue;
60204 // void ReceiveTlvs_set_payment_context(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKPaymentContext val);
60206 export function ReceiveTlvs_set_payment_context(this_ptr: bigint, val: bigint): void {
60207 if(!isWasmInitialized) {
60208 throw new Error("initializeWasm() must be awaited first!");
60210 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_context(this_ptr, val);
60211 // debug statements here
60213 // MUST_USE_RES struct LDKReceiveTlvs ReceiveTlvs_new(struct LDKThirtyTwoBytes payment_secret_arg, struct LDKPaymentConstraints payment_constraints_arg, struct LDKPaymentContext payment_context_arg);
60215 export function ReceiveTlvs_new(payment_secret_arg: number, payment_constraints_arg: bigint, payment_context_arg: bigint): bigint {
60216 if(!isWasmInitialized) {
60217 throw new Error("initializeWasm() must be awaited first!");
60219 const nativeResponseValue = wasm.TS_ReceiveTlvs_new(payment_secret_arg, payment_constraints_arg, payment_context_arg);
60220 return nativeResponseValue;
60222 // uint64_t ReceiveTlvs_clone_ptr(LDKReceiveTlvs *NONNULL_PTR arg);
60224 export function ReceiveTlvs_clone_ptr(arg: bigint): bigint {
60225 if(!isWasmInitialized) {
60226 throw new Error("initializeWasm() must be awaited first!");
60228 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone_ptr(arg);
60229 return nativeResponseValue;
60231 // struct LDKReceiveTlvs ReceiveTlvs_clone(const struct LDKReceiveTlvs *NONNULL_PTR orig);
60233 export function ReceiveTlvs_clone(orig: bigint): bigint {
60234 if(!isWasmInitialized) {
60235 throw new Error("initializeWasm() must be awaited first!");
60237 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone(orig);
60238 return nativeResponseValue;
60240 // void PaymentRelay_free(struct LDKPaymentRelay this_obj);
60242 export function PaymentRelay_free(this_obj: bigint): void {
60243 if(!isWasmInitialized) {
60244 throw new Error("initializeWasm() must be awaited first!");
60246 const nativeResponseValue = wasm.TS_PaymentRelay_free(this_obj);
60247 // debug statements here
60249 // uint16_t PaymentRelay_get_cltv_expiry_delta(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
60251 export function PaymentRelay_get_cltv_expiry_delta(this_ptr: bigint): number {
60252 if(!isWasmInitialized) {
60253 throw new Error("initializeWasm() must be awaited first!");
60255 const nativeResponseValue = wasm.TS_PaymentRelay_get_cltv_expiry_delta(this_ptr);
60256 return nativeResponseValue;
60258 // void PaymentRelay_set_cltv_expiry_delta(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint16_t val);
60260 export function PaymentRelay_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
60261 if(!isWasmInitialized) {
60262 throw new Error("initializeWasm() must be awaited first!");
60264 const nativeResponseValue = wasm.TS_PaymentRelay_set_cltv_expiry_delta(this_ptr, val);
60265 // debug statements here
60267 // uint32_t PaymentRelay_get_fee_proportional_millionths(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
60269 export function PaymentRelay_get_fee_proportional_millionths(this_ptr: bigint): number {
60270 if(!isWasmInitialized) {
60271 throw new Error("initializeWasm() must be awaited first!");
60273 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_proportional_millionths(this_ptr);
60274 return nativeResponseValue;
60276 // void PaymentRelay_set_fee_proportional_millionths(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
60278 export function PaymentRelay_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
60279 if(!isWasmInitialized) {
60280 throw new Error("initializeWasm() must be awaited first!");
60282 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_proportional_millionths(this_ptr, val);
60283 // debug statements here
60285 // uint32_t PaymentRelay_get_fee_base_msat(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
60287 export function PaymentRelay_get_fee_base_msat(this_ptr: bigint): number {
60288 if(!isWasmInitialized) {
60289 throw new Error("initializeWasm() must be awaited first!");
60291 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_base_msat(this_ptr);
60292 return nativeResponseValue;
60294 // void PaymentRelay_set_fee_base_msat(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
60296 export function PaymentRelay_set_fee_base_msat(this_ptr: bigint, val: number): void {
60297 if(!isWasmInitialized) {
60298 throw new Error("initializeWasm() must be awaited first!");
60300 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_base_msat(this_ptr, val);
60301 // debug statements here
60303 // MUST_USE_RES struct LDKPaymentRelay PaymentRelay_new(uint16_t cltv_expiry_delta_arg, uint32_t fee_proportional_millionths_arg, uint32_t fee_base_msat_arg);
60305 export function PaymentRelay_new(cltv_expiry_delta_arg: number, fee_proportional_millionths_arg: number, fee_base_msat_arg: number): bigint {
60306 if(!isWasmInitialized) {
60307 throw new Error("initializeWasm() must be awaited first!");
60309 const nativeResponseValue = wasm.TS_PaymentRelay_new(cltv_expiry_delta_arg, fee_proportional_millionths_arg, fee_base_msat_arg);
60310 return nativeResponseValue;
60312 // uint64_t PaymentRelay_clone_ptr(LDKPaymentRelay *NONNULL_PTR arg);
60314 export function PaymentRelay_clone_ptr(arg: bigint): bigint {
60315 if(!isWasmInitialized) {
60316 throw new Error("initializeWasm() must be awaited first!");
60318 const nativeResponseValue = wasm.TS_PaymentRelay_clone_ptr(arg);
60319 return nativeResponseValue;
60321 // struct LDKPaymentRelay PaymentRelay_clone(const struct LDKPaymentRelay *NONNULL_PTR orig);
60323 export function PaymentRelay_clone(orig: bigint): bigint {
60324 if(!isWasmInitialized) {
60325 throw new Error("initializeWasm() must be awaited first!");
60327 const nativeResponseValue = wasm.TS_PaymentRelay_clone(orig);
60328 return nativeResponseValue;
60330 // void PaymentConstraints_free(struct LDKPaymentConstraints this_obj);
60332 export function PaymentConstraints_free(this_obj: bigint): void {
60333 if(!isWasmInitialized) {
60334 throw new Error("initializeWasm() must be awaited first!");
60336 const nativeResponseValue = wasm.TS_PaymentConstraints_free(this_obj);
60337 // debug statements here
60339 // uint32_t PaymentConstraints_get_max_cltv_expiry(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
60341 export function PaymentConstraints_get_max_cltv_expiry(this_ptr: bigint): number {
60342 if(!isWasmInitialized) {
60343 throw new Error("initializeWasm() must be awaited first!");
60345 const nativeResponseValue = wasm.TS_PaymentConstraints_get_max_cltv_expiry(this_ptr);
60346 return nativeResponseValue;
60348 // void PaymentConstraints_set_max_cltv_expiry(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint32_t val);
60350 export function PaymentConstraints_set_max_cltv_expiry(this_ptr: bigint, val: number): void {
60351 if(!isWasmInitialized) {
60352 throw new Error("initializeWasm() must be awaited first!");
60354 const nativeResponseValue = wasm.TS_PaymentConstraints_set_max_cltv_expiry(this_ptr, val);
60355 // debug statements here
60357 // uint64_t PaymentConstraints_get_htlc_minimum_msat(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
60359 export function PaymentConstraints_get_htlc_minimum_msat(this_ptr: bigint): bigint {
60360 if(!isWasmInitialized) {
60361 throw new Error("initializeWasm() must be awaited first!");
60363 const nativeResponseValue = wasm.TS_PaymentConstraints_get_htlc_minimum_msat(this_ptr);
60364 return nativeResponseValue;
60366 // void PaymentConstraints_set_htlc_minimum_msat(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint64_t val);
60368 export function PaymentConstraints_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
60369 if(!isWasmInitialized) {
60370 throw new Error("initializeWasm() must be awaited first!");
60372 const nativeResponseValue = wasm.TS_PaymentConstraints_set_htlc_minimum_msat(this_ptr, val);
60373 // debug statements here
60375 // MUST_USE_RES struct LDKPaymentConstraints PaymentConstraints_new(uint32_t max_cltv_expiry_arg, uint64_t htlc_minimum_msat_arg);
60377 export function PaymentConstraints_new(max_cltv_expiry_arg: number, htlc_minimum_msat_arg: bigint): bigint {
60378 if(!isWasmInitialized) {
60379 throw new Error("initializeWasm() must be awaited first!");
60381 const nativeResponseValue = wasm.TS_PaymentConstraints_new(max_cltv_expiry_arg, htlc_minimum_msat_arg);
60382 return nativeResponseValue;
60384 // uint64_t PaymentConstraints_clone_ptr(LDKPaymentConstraints *NONNULL_PTR arg);
60386 export function PaymentConstraints_clone_ptr(arg: bigint): bigint {
60387 if(!isWasmInitialized) {
60388 throw new Error("initializeWasm() must be awaited first!");
60390 const nativeResponseValue = wasm.TS_PaymentConstraints_clone_ptr(arg);
60391 return nativeResponseValue;
60393 // struct LDKPaymentConstraints PaymentConstraints_clone(const struct LDKPaymentConstraints *NONNULL_PTR orig);
60395 export function PaymentConstraints_clone(orig: bigint): bigint {
60396 if(!isWasmInitialized) {
60397 throw new Error("initializeWasm() must be awaited first!");
60399 const nativeResponseValue = wasm.TS_PaymentConstraints_clone(orig);
60400 return nativeResponseValue;
60402 // void PaymentContext_free(struct LDKPaymentContext this_ptr);
60404 export function PaymentContext_free(this_ptr: bigint): void {
60405 if(!isWasmInitialized) {
60406 throw new Error("initializeWasm() must be awaited first!");
60408 const nativeResponseValue = wasm.TS_PaymentContext_free(this_ptr);
60409 // debug statements here
60411 // uint64_t PaymentContext_clone_ptr(LDKPaymentContext *NONNULL_PTR arg);
60413 export function PaymentContext_clone_ptr(arg: bigint): bigint {
60414 if(!isWasmInitialized) {
60415 throw new Error("initializeWasm() must be awaited first!");
60417 const nativeResponseValue = wasm.TS_PaymentContext_clone_ptr(arg);
60418 return nativeResponseValue;
60420 // struct LDKPaymentContext PaymentContext_clone(const struct LDKPaymentContext *NONNULL_PTR orig);
60422 export function PaymentContext_clone(orig: bigint): bigint {
60423 if(!isWasmInitialized) {
60424 throw new Error("initializeWasm() must be awaited first!");
60426 const nativeResponseValue = wasm.TS_PaymentContext_clone(orig);
60427 return nativeResponseValue;
60429 // struct LDKPaymentContext PaymentContext_unknown(struct LDKUnknownPaymentContext a);
60431 export function PaymentContext_unknown(a: bigint): bigint {
60432 if(!isWasmInitialized) {
60433 throw new Error("initializeWasm() must be awaited first!");
60435 const nativeResponseValue = wasm.TS_PaymentContext_unknown(a);
60436 return nativeResponseValue;
60438 // struct LDKPaymentContext PaymentContext_bolt12_offer(struct LDKBolt12OfferContext a);
60440 export function PaymentContext_bolt12_offer(a: bigint): bigint {
60441 if(!isWasmInitialized) {
60442 throw new Error("initializeWasm() must be awaited first!");
60444 const nativeResponseValue = wasm.TS_PaymentContext_bolt12_offer(a);
60445 return nativeResponseValue;
60447 // struct LDKPaymentContext PaymentContext_bolt12_refund(struct LDKBolt12RefundContext a);
60449 export function PaymentContext_bolt12_refund(a: bigint): bigint {
60450 if(!isWasmInitialized) {
60451 throw new Error("initializeWasm() must be awaited first!");
60453 const nativeResponseValue = wasm.TS_PaymentContext_bolt12_refund(a);
60454 return nativeResponseValue;
60456 // bool PaymentContext_eq(const struct LDKPaymentContext *NONNULL_PTR a, const struct LDKPaymentContext *NONNULL_PTR b);
60458 export function PaymentContext_eq(a: bigint, b: bigint): boolean {
60459 if(!isWasmInitialized) {
60460 throw new Error("initializeWasm() must be awaited first!");
60462 const nativeResponseValue = wasm.TS_PaymentContext_eq(a, b);
60463 return nativeResponseValue;
60465 // void UnknownPaymentContext_free(struct LDKUnknownPaymentContext this_obj);
60467 export function UnknownPaymentContext_free(this_obj: bigint): void {
60468 if(!isWasmInitialized) {
60469 throw new Error("initializeWasm() must be awaited first!");
60471 const nativeResponseValue = wasm.TS_UnknownPaymentContext_free(this_obj);
60472 // debug statements here
60474 // uint64_t UnknownPaymentContext_clone_ptr(LDKUnknownPaymentContext *NONNULL_PTR arg);
60476 export function UnknownPaymentContext_clone_ptr(arg: bigint): bigint {
60477 if(!isWasmInitialized) {
60478 throw new Error("initializeWasm() must be awaited first!");
60480 const nativeResponseValue = wasm.TS_UnknownPaymentContext_clone_ptr(arg);
60481 return nativeResponseValue;
60483 // struct LDKUnknownPaymentContext UnknownPaymentContext_clone(const struct LDKUnknownPaymentContext *NONNULL_PTR orig);
60485 export function UnknownPaymentContext_clone(orig: bigint): bigint {
60486 if(!isWasmInitialized) {
60487 throw new Error("initializeWasm() must be awaited first!");
60489 const nativeResponseValue = wasm.TS_UnknownPaymentContext_clone(orig);
60490 return nativeResponseValue;
60492 // bool UnknownPaymentContext_eq(const struct LDKUnknownPaymentContext *NONNULL_PTR a, const struct LDKUnknownPaymentContext *NONNULL_PTR b);
60494 export function UnknownPaymentContext_eq(a: bigint, b: bigint): boolean {
60495 if(!isWasmInitialized) {
60496 throw new Error("initializeWasm() must be awaited first!");
60498 const nativeResponseValue = wasm.TS_UnknownPaymentContext_eq(a, b);
60499 return nativeResponseValue;
60501 // void Bolt12OfferContext_free(struct LDKBolt12OfferContext this_obj);
60503 export function Bolt12OfferContext_free(this_obj: bigint): void {
60504 if(!isWasmInitialized) {
60505 throw new Error("initializeWasm() must be awaited first!");
60507 const nativeResponseValue = wasm.TS_Bolt12OfferContext_free(this_obj);
60508 // debug statements here
60510 // struct LDKOfferId Bolt12OfferContext_get_offer_id(const struct LDKBolt12OfferContext *NONNULL_PTR this_ptr);
60512 export function Bolt12OfferContext_get_offer_id(this_ptr: bigint): bigint {
60513 if(!isWasmInitialized) {
60514 throw new Error("initializeWasm() must be awaited first!");
60516 const nativeResponseValue = wasm.TS_Bolt12OfferContext_get_offer_id(this_ptr);
60517 return nativeResponseValue;
60519 // void Bolt12OfferContext_set_offer_id(struct LDKBolt12OfferContext *NONNULL_PTR this_ptr, struct LDKOfferId val);
60521 export function Bolt12OfferContext_set_offer_id(this_ptr: bigint, val: bigint): void {
60522 if(!isWasmInitialized) {
60523 throw new Error("initializeWasm() must be awaited first!");
60525 const nativeResponseValue = wasm.TS_Bolt12OfferContext_set_offer_id(this_ptr, val);
60526 // debug statements here
60528 // struct LDKInvoiceRequestFields Bolt12OfferContext_get_invoice_request(const struct LDKBolt12OfferContext *NONNULL_PTR this_ptr);
60530 export function Bolt12OfferContext_get_invoice_request(this_ptr: bigint): bigint {
60531 if(!isWasmInitialized) {
60532 throw new Error("initializeWasm() must be awaited first!");
60534 const nativeResponseValue = wasm.TS_Bolt12OfferContext_get_invoice_request(this_ptr);
60535 return nativeResponseValue;
60537 // void Bolt12OfferContext_set_invoice_request(struct LDKBolt12OfferContext *NONNULL_PTR this_ptr, struct LDKInvoiceRequestFields val);
60539 export function Bolt12OfferContext_set_invoice_request(this_ptr: bigint, val: bigint): void {
60540 if(!isWasmInitialized) {
60541 throw new Error("initializeWasm() must be awaited first!");
60543 const nativeResponseValue = wasm.TS_Bolt12OfferContext_set_invoice_request(this_ptr, val);
60544 // debug statements here
60546 // MUST_USE_RES struct LDKBolt12OfferContext Bolt12OfferContext_new(struct LDKOfferId offer_id_arg, struct LDKInvoiceRequestFields invoice_request_arg);
60548 export function Bolt12OfferContext_new(offer_id_arg: bigint, invoice_request_arg: bigint): bigint {
60549 if(!isWasmInitialized) {
60550 throw new Error("initializeWasm() must be awaited first!");
60552 const nativeResponseValue = wasm.TS_Bolt12OfferContext_new(offer_id_arg, invoice_request_arg);
60553 return nativeResponseValue;
60555 // uint64_t Bolt12OfferContext_clone_ptr(LDKBolt12OfferContext *NONNULL_PTR arg);
60557 export function Bolt12OfferContext_clone_ptr(arg: bigint): bigint {
60558 if(!isWasmInitialized) {
60559 throw new Error("initializeWasm() must be awaited first!");
60561 const nativeResponseValue = wasm.TS_Bolt12OfferContext_clone_ptr(arg);
60562 return nativeResponseValue;
60564 // struct LDKBolt12OfferContext Bolt12OfferContext_clone(const struct LDKBolt12OfferContext *NONNULL_PTR orig);
60566 export function Bolt12OfferContext_clone(orig: bigint): bigint {
60567 if(!isWasmInitialized) {
60568 throw new Error("initializeWasm() must be awaited first!");
60570 const nativeResponseValue = wasm.TS_Bolt12OfferContext_clone(orig);
60571 return nativeResponseValue;
60573 // bool Bolt12OfferContext_eq(const struct LDKBolt12OfferContext *NONNULL_PTR a, const struct LDKBolt12OfferContext *NONNULL_PTR b);
60575 export function Bolt12OfferContext_eq(a: bigint, b: bigint): boolean {
60576 if(!isWasmInitialized) {
60577 throw new Error("initializeWasm() must be awaited first!");
60579 const nativeResponseValue = wasm.TS_Bolt12OfferContext_eq(a, b);
60580 return nativeResponseValue;
60582 // void Bolt12RefundContext_free(struct LDKBolt12RefundContext this_obj);
60584 export function Bolt12RefundContext_free(this_obj: bigint): void {
60585 if(!isWasmInitialized) {
60586 throw new Error("initializeWasm() must be awaited first!");
60588 const nativeResponseValue = wasm.TS_Bolt12RefundContext_free(this_obj);
60589 // debug statements here
60591 // MUST_USE_RES struct LDKBolt12RefundContext Bolt12RefundContext_new(void);
60593 export function Bolt12RefundContext_new(): bigint {
60594 if(!isWasmInitialized) {
60595 throw new Error("initializeWasm() must be awaited first!");
60597 const nativeResponseValue = wasm.TS_Bolt12RefundContext_new();
60598 return nativeResponseValue;
60600 // uint64_t Bolt12RefundContext_clone_ptr(LDKBolt12RefundContext *NONNULL_PTR arg);
60602 export function Bolt12RefundContext_clone_ptr(arg: bigint): bigint {
60603 if(!isWasmInitialized) {
60604 throw new Error("initializeWasm() must be awaited first!");
60606 const nativeResponseValue = wasm.TS_Bolt12RefundContext_clone_ptr(arg);
60607 return nativeResponseValue;
60609 // struct LDKBolt12RefundContext Bolt12RefundContext_clone(const struct LDKBolt12RefundContext *NONNULL_PTR orig);
60611 export function Bolt12RefundContext_clone(orig: bigint): bigint {
60612 if(!isWasmInitialized) {
60613 throw new Error("initializeWasm() must be awaited first!");
60615 const nativeResponseValue = wasm.TS_Bolt12RefundContext_clone(orig);
60616 return nativeResponseValue;
60618 // bool Bolt12RefundContext_eq(const struct LDKBolt12RefundContext *NONNULL_PTR a, const struct LDKBolt12RefundContext *NONNULL_PTR b);
60620 export function Bolt12RefundContext_eq(a: bigint, b: bigint): boolean {
60621 if(!isWasmInitialized) {
60622 throw new Error("initializeWasm() must be awaited first!");
60624 const nativeResponseValue = wasm.TS_Bolt12RefundContext_eq(a, b);
60625 return nativeResponseValue;
60627 // struct LDKCVec_u8Z ForwardTlvs_write(const struct LDKForwardTlvs *NONNULL_PTR obj);
60629 export function ForwardTlvs_write(obj: bigint): number {
60630 if(!isWasmInitialized) {
60631 throw new Error("initializeWasm() must be awaited first!");
60633 const nativeResponseValue = wasm.TS_ForwardTlvs_write(obj);
60634 return nativeResponseValue;
60636 // struct LDKCVec_u8Z ReceiveTlvs_write(const struct LDKReceiveTlvs *NONNULL_PTR obj);
60638 export function ReceiveTlvs_write(obj: bigint): number {
60639 if(!isWasmInitialized) {
60640 throw new Error("initializeWasm() must be awaited first!");
60642 const nativeResponseValue = wasm.TS_ReceiveTlvs_write(obj);
60643 return nativeResponseValue;
60645 // struct LDKCVec_u8Z PaymentRelay_write(const struct LDKPaymentRelay *NONNULL_PTR obj);
60647 export function PaymentRelay_write(obj: bigint): number {
60648 if(!isWasmInitialized) {
60649 throw new Error("initializeWasm() must be awaited first!");
60651 const nativeResponseValue = wasm.TS_PaymentRelay_write(obj);
60652 return nativeResponseValue;
60654 // struct LDKCResult_PaymentRelayDecodeErrorZ PaymentRelay_read(struct LDKu8slice ser);
60656 export function PaymentRelay_read(ser: number): bigint {
60657 if(!isWasmInitialized) {
60658 throw new Error("initializeWasm() must be awaited first!");
60660 const nativeResponseValue = wasm.TS_PaymentRelay_read(ser);
60661 return nativeResponseValue;
60663 // struct LDKCVec_u8Z PaymentConstraints_write(const struct LDKPaymentConstraints *NONNULL_PTR obj);
60665 export function PaymentConstraints_write(obj: bigint): number {
60666 if(!isWasmInitialized) {
60667 throw new Error("initializeWasm() must be awaited first!");
60669 const nativeResponseValue = wasm.TS_PaymentConstraints_write(obj);
60670 return nativeResponseValue;
60672 // struct LDKCResult_PaymentConstraintsDecodeErrorZ PaymentConstraints_read(struct LDKu8slice ser);
60674 export function PaymentConstraints_read(ser: number): bigint {
60675 if(!isWasmInitialized) {
60676 throw new Error("initializeWasm() must be awaited first!");
60678 const nativeResponseValue = wasm.TS_PaymentConstraints_read(ser);
60679 return nativeResponseValue;
60681 // struct LDKCVec_u8Z PaymentContext_write(const struct LDKPaymentContext *NONNULL_PTR obj);
60683 export function PaymentContext_write(obj: bigint): number {
60684 if(!isWasmInitialized) {
60685 throw new Error("initializeWasm() must be awaited first!");
60687 const nativeResponseValue = wasm.TS_PaymentContext_write(obj);
60688 return nativeResponseValue;
60690 // struct LDKCResult_PaymentContextDecodeErrorZ PaymentContext_read(struct LDKu8slice ser);
60692 export function PaymentContext_read(ser: number): bigint {
60693 if(!isWasmInitialized) {
60694 throw new Error("initializeWasm() must be awaited first!");
60696 const nativeResponseValue = wasm.TS_PaymentContext_read(ser);
60697 return nativeResponseValue;
60699 // struct LDKCVec_u8Z UnknownPaymentContext_write(const struct LDKUnknownPaymentContext *NONNULL_PTR obj);
60701 export function UnknownPaymentContext_write(obj: bigint): number {
60702 if(!isWasmInitialized) {
60703 throw new Error("initializeWasm() must be awaited first!");
60705 const nativeResponseValue = wasm.TS_UnknownPaymentContext_write(obj);
60706 return nativeResponseValue;
60708 // struct LDKCResult_UnknownPaymentContextDecodeErrorZ UnknownPaymentContext_read(struct LDKu8slice ser);
60710 export function UnknownPaymentContext_read(ser: number): bigint {
60711 if(!isWasmInitialized) {
60712 throw new Error("initializeWasm() must be awaited first!");
60714 const nativeResponseValue = wasm.TS_UnknownPaymentContext_read(ser);
60715 return nativeResponseValue;
60717 // struct LDKCVec_u8Z Bolt12OfferContext_write(const struct LDKBolt12OfferContext *NONNULL_PTR obj);
60719 export function Bolt12OfferContext_write(obj: bigint): number {
60720 if(!isWasmInitialized) {
60721 throw new Error("initializeWasm() must be awaited first!");
60723 const nativeResponseValue = wasm.TS_Bolt12OfferContext_write(obj);
60724 return nativeResponseValue;
60726 // struct LDKCResult_Bolt12OfferContextDecodeErrorZ Bolt12OfferContext_read(struct LDKu8slice ser);
60728 export function Bolt12OfferContext_read(ser: number): bigint {
60729 if(!isWasmInitialized) {
60730 throw new Error("initializeWasm() must be awaited first!");
60732 const nativeResponseValue = wasm.TS_Bolt12OfferContext_read(ser);
60733 return nativeResponseValue;
60735 // struct LDKCVec_u8Z Bolt12RefundContext_write(const struct LDKBolt12RefundContext *NONNULL_PTR obj);
60737 export function Bolt12RefundContext_write(obj: bigint): number {
60738 if(!isWasmInitialized) {
60739 throw new Error("initializeWasm() must be awaited first!");
60741 const nativeResponseValue = wasm.TS_Bolt12RefundContext_write(obj);
60742 return nativeResponseValue;
60744 // struct LDKCResult_Bolt12RefundContextDecodeErrorZ Bolt12RefundContext_read(struct LDKu8slice ser);
60746 export function Bolt12RefundContext_read(ser: number): bigint {
60747 if(!isWasmInitialized) {
60748 throw new Error("initializeWasm() must be awaited first!");
60750 const nativeResponseValue = wasm.TS_Bolt12RefundContext_read(ser);
60751 return nativeResponseValue;
60753 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
60755 export function PaymentPurpose_free(this_ptr: bigint): void {
60756 if(!isWasmInitialized) {
60757 throw new Error("initializeWasm() must be awaited first!");
60759 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
60760 // debug statements here
60762 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
60764 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
60765 if(!isWasmInitialized) {
60766 throw new Error("initializeWasm() must be awaited first!");
60768 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
60769 return nativeResponseValue;
60771 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
60773 export function PaymentPurpose_clone(orig: bigint): bigint {
60774 if(!isWasmInitialized) {
60775 throw new Error("initializeWasm() must be awaited first!");
60777 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
60778 return nativeResponseValue;
60780 // struct LDKPaymentPurpose PaymentPurpose_bolt11_invoice_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret);
60782 export function PaymentPurpose_bolt11_invoice_payment(payment_preimage: bigint, payment_secret: number): bigint {
60783 if(!isWasmInitialized) {
60784 throw new Error("initializeWasm() must be awaited first!");
60786 const nativeResponseValue = wasm.TS_PaymentPurpose_bolt11_invoice_payment(payment_preimage, payment_secret);
60787 return nativeResponseValue;
60789 // struct LDKPaymentPurpose PaymentPurpose_bolt12_offer_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret, struct LDKBolt12OfferContext payment_context);
60791 export function PaymentPurpose_bolt12_offer_payment(payment_preimage: bigint, payment_secret: number, payment_context: bigint): bigint {
60792 if(!isWasmInitialized) {
60793 throw new Error("initializeWasm() must be awaited first!");
60795 const nativeResponseValue = wasm.TS_PaymentPurpose_bolt12_offer_payment(payment_preimage, payment_secret, payment_context);
60796 return nativeResponseValue;
60798 // struct LDKPaymentPurpose PaymentPurpose_bolt12_refund_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret, struct LDKBolt12RefundContext payment_context);
60800 export function PaymentPurpose_bolt12_refund_payment(payment_preimage: bigint, payment_secret: number, payment_context: bigint): bigint {
60801 if(!isWasmInitialized) {
60802 throw new Error("initializeWasm() must be awaited first!");
60804 const nativeResponseValue = wasm.TS_PaymentPurpose_bolt12_refund_payment(payment_preimage, payment_secret, payment_context);
60805 return nativeResponseValue;
60807 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
60809 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
60810 if(!isWasmInitialized) {
60811 throw new Error("initializeWasm() must be awaited first!");
60813 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
60814 return nativeResponseValue;
60816 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
60818 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
60819 if(!isWasmInitialized) {
60820 throw new Error("initializeWasm() must be awaited first!");
60822 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
60823 return nativeResponseValue;
60825 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ PaymentPurpose_preimage(const struct LDKPaymentPurpose *NONNULL_PTR this_arg);
60827 export function PaymentPurpose_preimage(this_arg: bigint): bigint {
60828 if(!isWasmInitialized) {
60829 throw new Error("initializeWasm() must be awaited first!");
60831 const nativeResponseValue = wasm.TS_PaymentPurpose_preimage(this_arg);
60832 return nativeResponseValue;
60834 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
60836 export function PaymentPurpose_write(obj: bigint): number {
60837 if(!isWasmInitialized) {
60838 throw new Error("initializeWasm() must be awaited first!");
60840 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
60841 return nativeResponseValue;
60843 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
60845 export function PaymentPurpose_read(ser: number): bigint {
60846 if(!isWasmInitialized) {
60847 throw new Error("initializeWasm() must be awaited first!");
60849 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
60850 return nativeResponseValue;
60852 // void ClaimedHTLC_free(struct LDKClaimedHTLC this_obj);
60854 export function ClaimedHTLC_free(this_obj: bigint): void {
60855 if(!isWasmInitialized) {
60856 throw new Error("initializeWasm() must be awaited first!");
60858 const nativeResponseValue = wasm.TS_ClaimedHTLC_free(this_obj);
60859 // debug statements here
60861 // struct LDKChannelId ClaimedHTLC_get_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
60863 export function ClaimedHTLC_get_channel_id(this_ptr: bigint): bigint {
60864 if(!isWasmInitialized) {
60865 throw new Error("initializeWasm() must be awaited first!");
60867 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_channel_id(this_ptr);
60868 return nativeResponseValue;
60870 // void ClaimedHTLC_set_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKChannelId val);
60872 export function ClaimedHTLC_set_channel_id(this_ptr: bigint, val: bigint): void {
60873 if(!isWasmInitialized) {
60874 throw new Error("initializeWasm() must be awaited first!");
60876 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_channel_id(this_ptr, val);
60877 // debug statements here
60879 // struct LDKU128 ClaimedHTLC_get_user_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
60881 export function ClaimedHTLC_get_user_channel_id(this_ptr: bigint): number {
60882 if(!isWasmInitialized) {
60883 throw new Error("initializeWasm() must be awaited first!");
60885 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_user_channel_id(this_ptr);
60886 return nativeResponseValue;
60888 // void ClaimedHTLC_set_user_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKU128 val);
60890 export function ClaimedHTLC_set_user_channel_id(this_ptr: bigint, val: number): void {
60891 if(!isWasmInitialized) {
60892 throw new Error("initializeWasm() must be awaited first!");
60894 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_user_channel_id(this_ptr, val);
60895 // debug statements here
60897 // uint32_t ClaimedHTLC_get_cltv_expiry(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
60899 export function ClaimedHTLC_get_cltv_expiry(this_ptr: bigint): number {
60900 if(!isWasmInitialized) {
60901 throw new Error("initializeWasm() must be awaited first!");
60903 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_cltv_expiry(this_ptr);
60904 return nativeResponseValue;
60906 // void ClaimedHTLC_set_cltv_expiry(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint32_t val);
60908 export function ClaimedHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
60909 if(!isWasmInitialized) {
60910 throw new Error("initializeWasm() must be awaited first!");
60912 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_cltv_expiry(this_ptr, val);
60913 // debug statements here
60915 // uint64_t ClaimedHTLC_get_value_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
60917 export function ClaimedHTLC_get_value_msat(this_ptr: bigint): bigint {
60918 if(!isWasmInitialized) {
60919 throw new Error("initializeWasm() must be awaited first!");
60921 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_value_msat(this_ptr);
60922 return nativeResponseValue;
60924 // void ClaimedHTLC_set_value_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
60926 export function ClaimedHTLC_set_value_msat(this_ptr: bigint, val: bigint): void {
60927 if(!isWasmInitialized) {
60928 throw new Error("initializeWasm() must be awaited first!");
60930 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_value_msat(this_ptr, val);
60931 // debug statements here
60933 // uint64_t ClaimedHTLC_get_counterparty_skimmed_fee_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
60935 export function ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr: bigint): bigint {
60936 if(!isWasmInitialized) {
60937 throw new Error("initializeWasm() must be awaited first!");
60939 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr);
60940 return nativeResponseValue;
60942 // void ClaimedHTLC_set_counterparty_skimmed_fee_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
60944 export function ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
60945 if(!isWasmInitialized) {
60946 throw new Error("initializeWasm() must be awaited first!");
60948 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr, val);
60949 // debug statements here
60951 // MUST_USE_RES struct LDKClaimedHTLC ClaimedHTLC_new(struct LDKChannelId channel_id_arg, struct LDKU128 user_channel_id_arg, uint32_t cltv_expiry_arg, uint64_t value_msat_arg, uint64_t counterparty_skimmed_fee_msat_arg);
60953 export function ClaimedHTLC_new(channel_id_arg: bigint, user_channel_id_arg: number, cltv_expiry_arg: number, value_msat_arg: bigint, counterparty_skimmed_fee_msat_arg: bigint): bigint {
60954 if(!isWasmInitialized) {
60955 throw new Error("initializeWasm() must be awaited first!");
60957 const nativeResponseValue = wasm.TS_ClaimedHTLC_new(channel_id_arg, user_channel_id_arg, cltv_expiry_arg, value_msat_arg, counterparty_skimmed_fee_msat_arg);
60958 return nativeResponseValue;
60960 // uint64_t ClaimedHTLC_clone_ptr(LDKClaimedHTLC *NONNULL_PTR arg);
60962 export function ClaimedHTLC_clone_ptr(arg: bigint): bigint {
60963 if(!isWasmInitialized) {
60964 throw new Error("initializeWasm() must be awaited first!");
60966 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone_ptr(arg);
60967 return nativeResponseValue;
60969 // struct LDKClaimedHTLC ClaimedHTLC_clone(const struct LDKClaimedHTLC *NONNULL_PTR orig);
60971 export function ClaimedHTLC_clone(orig: bigint): bigint {
60972 if(!isWasmInitialized) {
60973 throw new Error("initializeWasm() must be awaited first!");
60975 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone(orig);
60976 return nativeResponseValue;
60978 // bool ClaimedHTLC_eq(const struct LDKClaimedHTLC *NONNULL_PTR a, const struct LDKClaimedHTLC *NONNULL_PTR b);
60980 export function ClaimedHTLC_eq(a: bigint, b: bigint): boolean {
60981 if(!isWasmInitialized) {
60982 throw new Error("initializeWasm() must be awaited first!");
60984 const nativeResponseValue = wasm.TS_ClaimedHTLC_eq(a, b);
60985 return nativeResponseValue;
60987 // struct LDKCVec_u8Z ClaimedHTLC_write(const struct LDKClaimedHTLC *NONNULL_PTR obj);
60989 export function ClaimedHTLC_write(obj: bigint): number {
60990 if(!isWasmInitialized) {
60991 throw new Error("initializeWasm() must be awaited first!");
60993 const nativeResponseValue = wasm.TS_ClaimedHTLC_write(obj);
60994 return nativeResponseValue;
60996 // struct LDKCResult_ClaimedHTLCDecodeErrorZ ClaimedHTLC_read(struct LDKu8slice ser);
60998 export function ClaimedHTLC_read(ser: number): bigint {
60999 if(!isWasmInitialized) {
61000 throw new Error("initializeWasm() must be awaited first!");
61002 const nativeResponseValue = wasm.TS_ClaimedHTLC_read(ser);
61003 return nativeResponseValue;
61005 // void PathFailure_free(struct LDKPathFailure this_ptr);
61007 export function PathFailure_free(this_ptr: bigint): void {
61008 if(!isWasmInitialized) {
61009 throw new Error("initializeWasm() must be awaited first!");
61011 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
61012 // debug statements here
61014 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
61016 export function PathFailure_clone_ptr(arg: bigint): bigint {
61017 if(!isWasmInitialized) {
61018 throw new Error("initializeWasm() must be awaited first!");
61020 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
61021 return nativeResponseValue;
61023 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
61025 export function PathFailure_clone(orig: bigint): bigint {
61026 if(!isWasmInitialized) {
61027 throw new Error("initializeWasm() must be awaited first!");
61029 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
61030 return nativeResponseValue;
61032 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
61034 export function PathFailure_initial_send(err: bigint): bigint {
61035 if(!isWasmInitialized) {
61036 throw new Error("initializeWasm() must be awaited first!");
61038 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
61039 return nativeResponseValue;
61041 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
61043 export function PathFailure_on_path(network_update: bigint): bigint {
61044 if(!isWasmInitialized) {
61045 throw new Error("initializeWasm() must be awaited first!");
61047 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
61048 return nativeResponseValue;
61050 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
61052 export function PathFailure_eq(a: bigint, b: bigint): boolean {
61053 if(!isWasmInitialized) {
61054 throw new Error("initializeWasm() must be awaited first!");
61056 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
61057 return nativeResponseValue;
61059 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
61061 export function PathFailure_write(obj: bigint): number {
61062 if(!isWasmInitialized) {
61063 throw new Error("initializeWasm() must be awaited first!");
61065 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
61066 return nativeResponseValue;
61068 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
61070 export function PathFailure_read(ser: number): bigint {
61071 if(!isWasmInitialized) {
61072 throw new Error("initializeWasm() must be awaited first!");
61074 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
61075 return nativeResponseValue;
61077 // void ClosureReason_free(struct LDKClosureReason this_ptr);
61079 export function ClosureReason_free(this_ptr: bigint): void {
61080 if(!isWasmInitialized) {
61081 throw new Error("initializeWasm() must be awaited first!");
61083 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
61084 // debug statements here
61086 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
61088 export function ClosureReason_clone_ptr(arg: bigint): bigint {
61089 if(!isWasmInitialized) {
61090 throw new Error("initializeWasm() must be awaited first!");
61092 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
61093 return nativeResponseValue;
61095 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
61097 export function ClosureReason_clone(orig: bigint): bigint {
61098 if(!isWasmInitialized) {
61099 throw new Error("initializeWasm() must be awaited first!");
61101 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
61102 return nativeResponseValue;
61104 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
61106 export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
61107 if(!isWasmInitialized) {
61108 throw new Error("initializeWasm() must be awaited first!");
61110 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
61111 return nativeResponseValue;
61113 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
61115 export function ClosureReason_holder_force_closed(): bigint {
61116 if(!isWasmInitialized) {
61117 throw new Error("initializeWasm() must be awaited first!");
61119 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
61120 return nativeResponseValue;
61122 // struct LDKClosureReason ClosureReason_legacy_cooperative_closure(void);
61124 export function ClosureReason_legacy_cooperative_closure(): bigint {
61125 if(!isWasmInitialized) {
61126 throw new Error("initializeWasm() must be awaited first!");
61128 const nativeResponseValue = wasm.TS_ClosureReason_legacy_cooperative_closure();
61129 return nativeResponseValue;
61131 // struct LDKClosureReason ClosureReason_counterparty_initiated_cooperative_closure(void);
61133 export function ClosureReason_counterparty_initiated_cooperative_closure(): bigint {
61134 if(!isWasmInitialized) {
61135 throw new Error("initializeWasm() must be awaited first!");
61137 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_initiated_cooperative_closure();
61138 return nativeResponseValue;
61140 // struct LDKClosureReason ClosureReason_locally_initiated_cooperative_closure(void);
61142 export function ClosureReason_locally_initiated_cooperative_closure(): bigint {
61143 if(!isWasmInitialized) {
61144 throw new Error("initializeWasm() must be awaited first!");
61146 const nativeResponseValue = wasm.TS_ClosureReason_locally_initiated_cooperative_closure();
61147 return nativeResponseValue;
61149 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
61151 export function ClosureReason_commitment_tx_confirmed(): bigint {
61152 if(!isWasmInitialized) {
61153 throw new Error("initializeWasm() must be awaited first!");
61155 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
61156 return nativeResponseValue;
61158 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
61160 export function ClosureReason_funding_timed_out(): bigint {
61161 if(!isWasmInitialized) {
61162 throw new Error("initializeWasm() must be awaited first!");
61164 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
61165 return nativeResponseValue;
61167 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
61169 export function ClosureReason_processing_error(err: number): bigint {
61170 if(!isWasmInitialized) {
61171 throw new Error("initializeWasm() must be awaited first!");
61173 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
61174 return nativeResponseValue;
61176 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
61178 export function ClosureReason_disconnected_peer(): bigint {
61179 if(!isWasmInitialized) {
61180 throw new Error("initializeWasm() must be awaited first!");
61182 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
61183 return nativeResponseValue;
61185 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
61187 export function ClosureReason_outdated_channel_manager(): bigint {
61188 if(!isWasmInitialized) {
61189 throw new Error("initializeWasm() must be awaited first!");
61191 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
61192 return nativeResponseValue;
61194 // struct LDKClosureReason ClosureReason_counterparty_coop_closed_unfunded_channel(void);
61196 export function ClosureReason_counterparty_coop_closed_unfunded_channel(): bigint {
61197 if(!isWasmInitialized) {
61198 throw new Error("initializeWasm() must be awaited first!");
61200 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_coop_closed_unfunded_channel();
61201 return nativeResponseValue;
61203 // struct LDKClosureReason ClosureReason_funding_batch_closure(void);
61205 export function ClosureReason_funding_batch_closure(): bigint {
61206 if(!isWasmInitialized) {
61207 throw new Error("initializeWasm() must be awaited first!");
61209 const nativeResponseValue = wasm.TS_ClosureReason_funding_batch_closure();
61210 return nativeResponseValue;
61212 // struct LDKClosureReason ClosureReason_htlcs_timed_out(void);
61214 export function ClosureReason_htlcs_timed_out(): bigint {
61215 if(!isWasmInitialized) {
61216 throw new Error("initializeWasm() must be awaited first!");
61218 const nativeResponseValue = wasm.TS_ClosureReason_htlcs_timed_out();
61219 return nativeResponseValue;
61221 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
61223 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
61224 if(!isWasmInitialized) {
61225 throw new Error("initializeWasm() must be awaited first!");
61227 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
61228 return nativeResponseValue;
61230 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
61232 export function ClosureReason_write(obj: bigint): number {
61233 if(!isWasmInitialized) {
61234 throw new Error("initializeWasm() must be awaited first!");
61236 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
61237 return nativeResponseValue;
61239 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
61241 export function ClosureReason_read(ser: number): bigint {
61242 if(!isWasmInitialized) {
61243 throw new Error("initializeWasm() must be awaited first!");
61245 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
61246 return nativeResponseValue;
61248 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
61250 export function HTLCDestination_free(this_ptr: bigint): void {
61251 if(!isWasmInitialized) {
61252 throw new Error("initializeWasm() must be awaited first!");
61254 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
61255 // debug statements here
61257 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
61259 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
61260 if(!isWasmInitialized) {
61261 throw new Error("initializeWasm() must be awaited first!");
61263 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
61264 return nativeResponseValue;
61266 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
61268 export function HTLCDestination_clone(orig: bigint): bigint {
61269 if(!isWasmInitialized) {
61270 throw new Error("initializeWasm() must be awaited first!");
61272 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
61273 return nativeResponseValue;
61275 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKChannelId channel_id);
61277 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: bigint): bigint {
61278 if(!isWasmInitialized) {
61279 throw new Error("initializeWasm() must be awaited first!");
61281 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
61282 return nativeResponseValue;
61284 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
61286 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
61287 if(!isWasmInitialized) {
61288 throw new Error("initializeWasm() must be awaited first!");
61290 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
61291 return nativeResponseValue;
61293 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
61295 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
61296 if(!isWasmInitialized) {
61297 throw new Error("initializeWasm() must be awaited first!");
61299 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
61300 return nativeResponseValue;
61302 // struct LDKHTLCDestination HTLCDestination_invalid_onion(void);
61304 export function HTLCDestination_invalid_onion(): bigint {
61305 if(!isWasmInitialized) {
61306 throw new Error("initializeWasm() must be awaited first!");
61308 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_onion();
61309 return nativeResponseValue;
61311 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
61313 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
61314 if(!isWasmInitialized) {
61315 throw new Error("initializeWasm() must be awaited first!");
61317 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
61318 return nativeResponseValue;
61320 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
61322 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
61323 if(!isWasmInitialized) {
61324 throw new Error("initializeWasm() must be awaited first!");
61326 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
61327 return nativeResponseValue;
61329 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
61331 export function HTLCDestination_write(obj: bigint): number {
61332 if(!isWasmInitialized) {
61333 throw new Error("initializeWasm() must be awaited first!");
61335 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
61336 return nativeResponseValue;
61338 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
61340 export function HTLCDestination_read(ser: number): bigint {
61341 if(!isWasmInitialized) {
61342 throw new Error("initializeWasm() must be awaited first!");
61344 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
61345 return nativeResponseValue;
61347 // enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
61349 export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
61350 if(!isWasmInitialized) {
61351 throw new Error("initializeWasm() must be awaited first!");
61353 const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
61354 return nativeResponseValue;
61356 // enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
61358 export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
61359 if(!isWasmInitialized) {
61360 throw new Error("initializeWasm() must be awaited first!");
61362 const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
61363 return nativeResponseValue;
61365 // enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
61367 export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
61368 if(!isWasmInitialized) {
61369 throw new Error("initializeWasm() must be awaited first!");
61371 const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
61372 return nativeResponseValue;
61374 // enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
61376 export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
61377 if(!isWasmInitialized) {
61378 throw new Error("initializeWasm() must be awaited first!");
61380 const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
61381 return nativeResponseValue;
61383 // enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
61385 export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
61386 if(!isWasmInitialized) {
61387 throw new Error("initializeWasm() must be awaited first!");
61389 const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
61390 return nativeResponseValue;
61392 // enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
61394 export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
61395 if(!isWasmInitialized) {
61396 throw new Error("initializeWasm() must be awaited first!");
61398 const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
61399 return nativeResponseValue;
61401 // enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
61403 export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
61404 if(!isWasmInitialized) {
61405 throw new Error("initializeWasm() must be awaited first!");
61407 const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
61408 return nativeResponseValue;
61410 // bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
61412 export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
61413 if(!isWasmInitialized) {
61414 throw new Error("initializeWasm() must be awaited first!");
61416 const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
61417 return nativeResponseValue;
61419 // struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
61421 export function PaymentFailureReason_write(obj: bigint): number {
61422 if(!isWasmInitialized) {
61423 throw new Error("initializeWasm() must be awaited first!");
61425 const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
61426 return nativeResponseValue;
61428 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
61430 export function PaymentFailureReason_read(ser: number): bigint {
61431 if(!isWasmInitialized) {
61432 throw new Error("initializeWasm() must be awaited first!");
61434 const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
61435 return nativeResponseValue;
61437 // void Event_free(struct LDKEvent this_ptr);
61439 export function Event_free(this_ptr: bigint): void {
61440 if(!isWasmInitialized) {
61441 throw new Error("initializeWasm() must be awaited first!");
61443 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
61444 // debug statements here
61446 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
61448 export function Event_clone_ptr(arg: bigint): bigint {
61449 if(!isWasmInitialized) {
61450 throw new Error("initializeWasm() must be awaited first!");
61452 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
61453 return nativeResponseValue;
61455 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
61457 export function Event_clone(orig: bigint): bigint {
61458 if(!isWasmInitialized) {
61459 throw new Error("initializeWasm() must be awaited first!");
61461 const nativeResponseValue = wasm.TS_Event_clone(orig);
61462 return nativeResponseValue;
61464 // struct LDKEvent Event_funding_generation_ready(struct LDKChannelId temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, struct LDKU128 user_channel_id);
61466 export function Event_funding_generation_ready(temporary_channel_id: bigint, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
61467 if(!isWasmInitialized) {
61468 throw new Error("initializeWasm() must be awaited first!");
61470 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
61471 return nativeResponseValue;
61473 // struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields onion_fields, uint64_t amount_msat, uint64_t counterparty_skimmed_fee_msat, struct LDKPaymentPurpose purpose, struct LDKChannelId via_channel_id, struct LDKCOption_U128Z via_user_channel_id, struct LDKCOption_u32Z claim_deadline);
61475 export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, onion_fields: bigint, amount_msat: bigint, counterparty_skimmed_fee_msat: bigint, purpose: bigint, via_channel_id: bigint, via_user_channel_id: bigint, claim_deadline: bigint): bigint {
61476 if(!isWasmInitialized) {
61477 throw new Error("initializeWasm() must be awaited first!");
61479 const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, onion_fields, amount_msat, counterparty_skimmed_fee_msat, purpose, via_channel_id, via_user_channel_id, claim_deadline);
61480 return nativeResponseValue;
61482 // struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKCVec_ClaimedHTLCZ htlcs, struct LDKCOption_u64Z sender_intended_total_msat);
61484 export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint, htlcs: number, sender_intended_total_msat: bigint): bigint {
61485 if(!isWasmInitialized) {
61486 throw new Error("initializeWasm() must be awaited first!");
61488 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose, htlcs, sender_intended_total_msat);
61489 return nativeResponseValue;
61491 // struct LDKEvent Event_connection_needed(struct LDKPublicKey node_id, struct LDKCVec_SocketAddressZ addresses);
61493 export function Event_connection_needed(node_id: number, addresses: number): bigint {
61494 if(!isWasmInitialized) {
61495 throw new Error("initializeWasm() must be awaited first!");
61497 const nativeResponseValue = wasm.TS_Event_connection_needed(node_id, addresses);
61498 return nativeResponseValue;
61500 // struct LDKEvent Event_invoice_request_failed(struct LDKThirtyTwoBytes payment_id);
61502 export function Event_invoice_request_failed(payment_id: number): bigint {
61503 if(!isWasmInitialized) {
61504 throw new Error("initializeWasm() must be awaited first!");
61506 const nativeResponseValue = wasm.TS_Event_invoice_request_failed(payment_id);
61507 return nativeResponseValue;
61509 // struct LDKEvent Event_payment_sent(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
61511 export function Event_payment_sent(payment_id: bigint, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
61512 if(!isWasmInitialized) {
61513 throw new Error("initializeWasm() must be awaited first!");
61515 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
61516 return nativeResponseValue;
61518 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
61520 export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
61521 if(!isWasmInitialized) {
61522 throw new Error("initializeWasm() must be awaited first!");
61524 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
61525 return nativeResponseValue;
61527 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKPath path);
61529 export function Event_payment_path_successful(payment_id: number, payment_hash: bigint, path: bigint): bigint {
61530 if(!isWasmInitialized) {
61531 throw new Error("initializeWasm() must be awaited first!");
61533 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
61534 return nativeResponseValue;
61536 // struct LDKEvent Event_payment_path_failed(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
61538 export function Event_payment_path_failed(payment_id: bigint, payment_hash: number, payment_failed_permanently: boolean, failure: bigint, path: bigint, short_channel_id: bigint): bigint {
61539 if(!isWasmInitialized) {
61540 throw new Error("initializeWasm() must be awaited first!");
61542 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
61543 return nativeResponseValue;
61545 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
61547 export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
61548 if(!isWasmInitialized) {
61549 throw new Error("initializeWasm() must be awaited first!");
61551 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
61552 return nativeResponseValue;
61554 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
61556 export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
61557 if(!isWasmInitialized) {
61558 throw new Error("initializeWasm() must be awaited first!");
61560 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
61561 return nativeResponseValue;
61563 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
61565 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
61566 if(!isWasmInitialized) {
61567 throw new Error("initializeWasm() must be awaited first!");
61569 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
61570 return nativeResponseValue;
61572 // 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);
61574 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 {
61575 if(!isWasmInitialized) {
61576 throw new Error("initializeWasm() must be awaited first!");
61578 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
61579 return nativeResponseValue;
61581 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs, struct LDKChannelId channel_id);
61583 export function Event_spendable_outputs(outputs: number, channel_id: bigint): bigint {
61584 if(!isWasmInitialized) {
61585 throw new Error("initializeWasm() must be awaited first!");
61587 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs, channel_id);
61588 return nativeResponseValue;
61590 // struct LDKEvent Event_payment_forwarded(struct LDKChannelId prev_channel_id, struct LDKChannelId next_channel_id, struct LDKCOption_U128Z prev_user_channel_id, struct LDKCOption_U128Z next_user_channel_id, struct LDKCOption_u64Z total_fee_earned_msat, struct LDKCOption_u64Z skimmed_fee_msat, bool claim_from_onchain_tx, struct LDKCOption_u64Z outbound_amount_forwarded_msat);
61592 export function Event_payment_forwarded(prev_channel_id: bigint, next_channel_id: bigint, prev_user_channel_id: bigint, next_user_channel_id: bigint, total_fee_earned_msat: bigint, skimmed_fee_msat: bigint, claim_from_onchain_tx: boolean, outbound_amount_forwarded_msat: bigint): bigint {
61593 if(!isWasmInitialized) {
61594 throw new Error("initializeWasm() must be awaited first!");
61596 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, prev_user_channel_id, next_user_channel_id, total_fee_earned_msat, skimmed_fee_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
61597 return nativeResponseValue;
61599 // struct LDKEvent Event_channel_pending(struct LDKChannelId channel_id, struct LDKU128 user_channel_id, struct LDKChannelId former_temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKOutPoint funding_txo, struct LDKChannelTypeFeatures channel_type);
61601 export function Event_channel_pending(channel_id: bigint, user_channel_id: number, former_temporary_channel_id: bigint, counterparty_node_id: number, funding_txo: bigint, channel_type: bigint): bigint {
61602 if(!isWasmInitialized) {
61603 throw new Error("initializeWasm() must be awaited first!");
61605 const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo, channel_type);
61606 return nativeResponseValue;
61608 // struct LDKEvent Event_channel_ready(struct LDKChannelId channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
61610 export function Event_channel_ready(channel_id: bigint, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
61611 if(!isWasmInitialized) {
61612 throw new Error("initializeWasm() must be awaited first!");
61614 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
61615 return nativeResponseValue;
61617 // struct LDKEvent Event_channel_closed(struct LDKChannelId channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u64Z channel_capacity_sats, struct LDKOutPoint channel_funding_txo);
61619 export function Event_channel_closed(channel_id: bigint, user_channel_id: number, reason: bigint, counterparty_node_id: number, channel_capacity_sats: bigint, channel_funding_txo: bigint): bigint {
61620 if(!isWasmInitialized) {
61621 throw new Error("initializeWasm() must be awaited first!");
61623 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason, counterparty_node_id, channel_capacity_sats, channel_funding_txo);
61624 return nativeResponseValue;
61626 // struct LDKEvent Event_discard_funding(struct LDKChannelId channel_id, struct LDKTransaction transaction);
61628 export function Event_discard_funding(channel_id: bigint, transaction: number): bigint {
61629 if(!isWasmInitialized) {
61630 throw new Error("initializeWasm() must be awaited first!");
61632 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
61633 return nativeResponseValue;
61635 // struct LDKEvent Event_open_channel_request(struct LDKChannelId temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
61637 export function Event_open_channel_request(temporary_channel_id: bigint, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
61638 if(!isWasmInitialized) {
61639 throw new Error("initializeWasm() must be awaited first!");
61641 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
61642 return nativeResponseValue;
61644 // struct LDKEvent Event_htlchandling_failed(struct LDKChannelId prev_channel_id, struct LDKHTLCDestination failed_next_destination);
61646 export function Event_htlchandling_failed(prev_channel_id: bigint, failed_next_destination: bigint): bigint {
61647 if(!isWasmInitialized) {
61648 throw new Error("initializeWasm() must be awaited first!");
61650 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
61651 return nativeResponseValue;
61653 // struct LDKEvent Event_bump_transaction(struct LDKBumpTransactionEvent a);
61655 export function Event_bump_transaction(a: bigint): bigint {
61656 if(!isWasmInitialized) {
61657 throw new Error("initializeWasm() must be awaited first!");
61659 const nativeResponseValue = wasm.TS_Event_bump_transaction(a);
61660 return nativeResponseValue;
61662 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
61664 export function Event_eq(a: bigint, b: bigint): boolean {
61665 if(!isWasmInitialized) {
61666 throw new Error("initializeWasm() must be awaited first!");
61668 const nativeResponseValue = wasm.TS_Event_eq(a, b);
61669 return nativeResponseValue;
61671 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
61673 export function Event_write(obj: bigint): number {
61674 if(!isWasmInitialized) {
61675 throw new Error("initializeWasm() must be awaited first!");
61677 const nativeResponseValue = wasm.TS_Event_write(obj);
61678 return nativeResponseValue;
61680 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
61682 export function Event_read(ser: number): bigint {
61683 if(!isWasmInitialized) {
61684 throw new Error("initializeWasm() must be awaited first!");
61686 const nativeResponseValue = wasm.TS_Event_read(ser);
61687 return nativeResponseValue;
61689 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
61691 export function MessageSendEvent_free(this_ptr: bigint): void {
61692 if(!isWasmInitialized) {
61693 throw new Error("initializeWasm() must be awaited first!");
61695 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
61696 // debug statements here
61698 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
61700 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
61701 if(!isWasmInitialized) {
61702 throw new Error("initializeWasm() must be awaited first!");
61704 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
61705 return nativeResponseValue;
61707 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
61709 export function MessageSendEvent_clone(orig: bigint): bigint {
61710 if(!isWasmInitialized) {
61711 throw new Error("initializeWasm() must be awaited first!");
61713 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
61714 return nativeResponseValue;
61716 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
61718 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
61719 if(!isWasmInitialized) {
61720 throw new Error("initializeWasm() must be awaited first!");
61722 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
61723 return nativeResponseValue;
61725 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel_v2(struct LDKPublicKey node_id, struct LDKAcceptChannelV2 msg);
61727 export function MessageSendEvent_send_accept_channel_v2(node_id: number, msg: bigint): bigint {
61728 if(!isWasmInitialized) {
61729 throw new Error("initializeWasm() must be awaited first!");
61731 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel_v2(node_id, msg);
61732 return nativeResponseValue;
61734 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
61736 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
61737 if(!isWasmInitialized) {
61738 throw new Error("initializeWasm() must be awaited first!");
61740 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
61741 return nativeResponseValue;
61743 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel_v2(struct LDKPublicKey node_id, struct LDKOpenChannelV2 msg);
61745 export function MessageSendEvent_send_open_channel_v2(node_id: number, msg: bigint): bigint {
61746 if(!isWasmInitialized) {
61747 throw new Error("initializeWasm() must be awaited first!");
61749 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel_v2(node_id, msg);
61750 return nativeResponseValue;
61752 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
61754 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
61755 if(!isWasmInitialized) {
61756 throw new Error("initializeWasm() must be awaited first!");
61758 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
61759 return nativeResponseValue;
61761 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
61763 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
61764 if(!isWasmInitialized) {
61765 throw new Error("initializeWasm() must be awaited first!");
61767 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
61768 return nativeResponseValue;
61770 // struct LDKMessageSendEvent MessageSendEvent_send_stfu(struct LDKPublicKey node_id, struct LDKStfu msg);
61772 export function MessageSendEvent_send_stfu(node_id: number, msg: bigint): bigint {
61773 if(!isWasmInitialized) {
61774 throw new Error("initializeWasm() must be awaited first!");
61776 const nativeResponseValue = wasm.TS_MessageSendEvent_send_stfu(node_id, msg);
61777 return nativeResponseValue;
61779 // struct LDKMessageSendEvent MessageSendEvent_send_splice(struct LDKPublicKey node_id, struct LDKSplice msg);
61781 export function MessageSendEvent_send_splice(node_id: number, msg: bigint): bigint {
61782 if(!isWasmInitialized) {
61783 throw new Error("initializeWasm() must be awaited first!");
61785 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice(node_id, msg);
61786 return nativeResponseValue;
61788 // struct LDKMessageSendEvent MessageSendEvent_send_splice_ack(struct LDKPublicKey node_id, struct LDKSpliceAck msg);
61790 export function MessageSendEvent_send_splice_ack(node_id: number, msg: bigint): bigint {
61791 if(!isWasmInitialized) {
61792 throw new Error("initializeWasm() must be awaited first!");
61794 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice_ack(node_id, msg);
61795 return nativeResponseValue;
61797 // struct LDKMessageSendEvent MessageSendEvent_send_splice_locked(struct LDKPublicKey node_id, struct LDKSpliceLocked msg);
61799 export function MessageSendEvent_send_splice_locked(node_id: number, msg: bigint): bigint {
61800 if(!isWasmInitialized) {
61801 throw new Error("initializeWasm() must be awaited first!");
61803 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice_locked(node_id, msg);
61804 return nativeResponseValue;
61806 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_input(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
61808 export function MessageSendEvent_send_tx_add_input(node_id: number, msg: bigint): bigint {
61809 if(!isWasmInitialized) {
61810 throw new Error("initializeWasm() must be awaited first!");
61812 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_input(node_id, msg);
61813 return nativeResponseValue;
61815 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_output(struct LDKPublicKey node_id, struct LDKTxAddOutput msg);
61817 export function MessageSendEvent_send_tx_add_output(node_id: number, msg: bigint): bigint {
61818 if(!isWasmInitialized) {
61819 throw new Error("initializeWasm() must be awaited first!");
61821 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_output(node_id, msg);
61822 return nativeResponseValue;
61824 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_input(struct LDKPublicKey node_id, struct LDKTxRemoveInput msg);
61826 export function MessageSendEvent_send_tx_remove_input(node_id: number, msg: bigint): bigint {
61827 if(!isWasmInitialized) {
61828 throw new Error("initializeWasm() must be awaited first!");
61830 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_input(node_id, msg);
61831 return nativeResponseValue;
61833 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_output(struct LDKPublicKey node_id, struct LDKTxRemoveOutput msg);
61835 export function MessageSendEvent_send_tx_remove_output(node_id: number, msg: bigint): bigint {
61836 if(!isWasmInitialized) {
61837 throw new Error("initializeWasm() must be awaited first!");
61839 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_output(node_id, msg);
61840 return nativeResponseValue;
61842 // struct LDKMessageSendEvent MessageSendEvent_send_tx_complete(struct LDKPublicKey node_id, struct LDKTxComplete msg);
61844 export function MessageSendEvent_send_tx_complete(node_id: number, msg: bigint): bigint {
61845 if(!isWasmInitialized) {
61846 throw new Error("initializeWasm() must be awaited first!");
61848 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_complete(node_id, msg);
61849 return nativeResponseValue;
61851 // struct LDKMessageSendEvent MessageSendEvent_send_tx_signatures(struct LDKPublicKey node_id, struct LDKTxSignatures msg);
61853 export function MessageSendEvent_send_tx_signatures(node_id: number, msg: bigint): bigint {
61854 if(!isWasmInitialized) {
61855 throw new Error("initializeWasm() must be awaited first!");
61857 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_signatures(node_id, msg);
61858 return nativeResponseValue;
61860 // struct LDKMessageSendEvent MessageSendEvent_send_tx_init_rbf(struct LDKPublicKey node_id, struct LDKTxInitRbf msg);
61862 export function MessageSendEvent_send_tx_init_rbf(node_id: number, msg: bigint): bigint {
61863 if(!isWasmInitialized) {
61864 throw new Error("initializeWasm() must be awaited first!");
61866 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_init_rbf(node_id, msg);
61867 return nativeResponseValue;
61869 // struct LDKMessageSendEvent MessageSendEvent_send_tx_ack_rbf(struct LDKPublicKey node_id, struct LDKTxAckRbf msg);
61871 export function MessageSendEvent_send_tx_ack_rbf(node_id: number, msg: bigint): bigint {
61872 if(!isWasmInitialized) {
61873 throw new Error("initializeWasm() must be awaited first!");
61875 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_ack_rbf(node_id, msg);
61876 return nativeResponseValue;
61878 // struct LDKMessageSendEvent MessageSendEvent_send_tx_abort(struct LDKPublicKey node_id, struct LDKTxAbort msg);
61880 export function MessageSendEvent_send_tx_abort(node_id: number, msg: bigint): bigint {
61881 if(!isWasmInitialized) {
61882 throw new Error("initializeWasm() must be awaited first!");
61884 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_abort(node_id, msg);
61885 return nativeResponseValue;
61887 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
61889 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
61890 if(!isWasmInitialized) {
61891 throw new Error("initializeWasm() must be awaited first!");
61893 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
61894 return nativeResponseValue;
61896 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
61898 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
61899 if(!isWasmInitialized) {
61900 throw new Error("initializeWasm() must be awaited first!");
61902 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
61903 return nativeResponseValue;
61905 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
61907 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
61908 if(!isWasmInitialized) {
61909 throw new Error("initializeWasm() must be awaited first!");
61911 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
61912 return nativeResponseValue;
61914 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
61916 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
61917 if(!isWasmInitialized) {
61918 throw new Error("initializeWasm() must be awaited first!");
61920 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
61921 return nativeResponseValue;
61923 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
61925 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
61926 if(!isWasmInitialized) {
61927 throw new Error("initializeWasm() must be awaited first!");
61929 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
61930 return nativeResponseValue;
61932 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
61934 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
61935 if(!isWasmInitialized) {
61936 throw new Error("initializeWasm() must be awaited first!");
61938 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
61939 return nativeResponseValue;
61941 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
61943 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
61944 if(!isWasmInitialized) {
61945 throw new Error("initializeWasm() must be awaited first!");
61947 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
61948 return nativeResponseValue;
61950 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
61952 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
61953 if(!isWasmInitialized) {
61954 throw new Error("initializeWasm() must be awaited first!");
61956 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
61957 return nativeResponseValue;
61959 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
61961 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
61962 if(!isWasmInitialized) {
61963 throw new Error("initializeWasm() must be awaited first!");
61965 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
61966 return nativeResponseValue;
61968 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
61970 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
61971 if(!isWasmInitialized) {
61972 throw new Error("initializeWasm() must be awaited first!");
61974 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
61975 return nativeResponseValue;
61977 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
61979 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
61980 if(!isWasmInitialized) {
61981 throw new Error("initializeWasm() must be awaited first!");
61983 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
61984 return nativeResponseValue;
61986 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
61988 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
61989 if(!isWasmInitialized) {
61990 throw new Error("initializeWasm() must be awaited first!");
61992 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
61993 return nativeResponseValue;
61995 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
61997 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
61998 if(!isWasmInitialized) {
61999 throw new Error("initializeWasm() must be awaited first!");
62001 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
62002 return nativeResponseValue;
62004 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
62006 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
62007 if(!isWasmInitialized) {
62008 throw new Error("initializeWasm() must be awaited first!");
62010 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
62011 return nativeResponseValue;
62013 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
62015 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
62016 if(!isWasmInitialized) {
62017 throw new Error("initializeWasm() must be awaited first!");
62019 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
62020 return nativeResponseValue;
62022 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
62024 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
62025 if(!isWasmInitialized) {
62026 throw new Error("initializeWasm() must be awaited first!");
62028 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
62029 return nativeResponseValue;
62031 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
62033 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
62034 if(!isWasmInitialized) {
62035 throw new Error("initializeWasm() must be awaited first!");
62037 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
62038 return nativeResponseValue;
62040 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
62042 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
62043 if(!isWasmInitialized) {
62044 throw new Error("initializeWasm() must be awaited first!");
62046 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
62047 // debug statements here
62049 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
62051 export function EventsProvider_free(this_ptr: bigint): void {
62052 if(!isWasmInitialized) {
62053 throw new Error("initializeWasm() must be awaited first!");
62055 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
62056 // debug statements here
62058 // void EventHandler_free(struct LDKEventHandler this_ptr);
62060 export function EventHandler_free(this_ptr: bigint): void {
62061 if(!isWasmInitialized) {
62062 throw new Error("initializeWasm() must be awaited first!");
62064 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
62065 // debug statements here
62067 // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
62069 export function AnchorDescriptor_free(this_obj: bigint): void {
62070 if(!isWasmInitialized) {
62071 throw new Error("initializeWasm() must be awaited first!");
62073 const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
62074 // debug statements here
62076 // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
62078 export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
62079 if(!isWasmInitialized) {
62080 throw new Error("initializeWasm() must be awaited first!");
62082 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
62083 return nativeResponseValue;
62085 // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
62087 export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
62088 if(!isWasmInitialized) {
62089 throw new Error("initializeWasm() must be awaited first!");
62091 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
62092 // debug statements here
62094 // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
62096 export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
62097 if(!isWasmInitialized) {
62098 throw new Error("initializeWasm() must be awaited first!");
62100 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
62101 return nativeResponseValue;
62103 // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
62105 export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
62106 if(!isWasmInitialized) {
62107 throw new Error("initializeWasm() must be awaited first!");
62109 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
62110 // debug statements here
62112 // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
62114 export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
62115 if(!isWasmInitialized) {
62116 throw new Error("initializeWasm() must be awaited first!");
62118 const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
62119 return nativeResponseValue;
62121 // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
62123 export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
62124 if(!isWasmInitialized) {
62125 throw new Error("initializeWasm() must be awaited first!");
62127 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
62128 return nativeResponseValue;
62130 // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
62132 export function AnchorDescriptor_clone(orig: bigint): bigint {
62133 if(!isWasmInitialized) {
62134 throw new Error("initializeWasm() must be awaited first!");
62136 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
62137 return nativeResponseValue;
62139 // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
62141 export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
62142 if(!isWasmInitialized) {
62143 throw new Error("initializeWasm() must be awaited first!");
62145 const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
62146 return nativeResponseValue;
62148 // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
62150 export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
62151 if(!isWasmInitialized) {
62152 throw new Error("initializeWasm() must be awaited first!");
62154 const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
62155 return nativeResponseValue;
62157 // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
62159 export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
62160 if(!isWasmInitialized) {
62161 throw new Error("initializeWasm() must be awaited first!");
62163 const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
62164 return nativeResponseValue;
62166 // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
62168 export function AnchorDescriptor_witness_script(this_arg: bigint): number {
62169 if(!isWasmInitialized) {
62170 throw new Error("initializeWasm() must be awaited first!");
62172 const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
62173 return nativeResponseValue;
62175 // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature);
62177 export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
62178 if(!isWasmInitialized) {
62179 throw new Error("initializeWasm() must be awaited first!");
62181 const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
62182 return nativeResponseValue;
62184 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
62186 export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
62187 if(!isWasmInitialized) {
62188 throw new Error("initializeWasm() must be awaited first!");
62190 const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
62191 return nativeResponseValue;
62193 // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
62195 export function BumpTransactionEvent_free(this_ptr: bigint): void {
62196 if(!isWasmInitialized) {
62197 throw new Error("initializeWasm() must be awaited first!");
62199 const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
62200 // debug statements here
62202 // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
62204 export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
62205 if(!isWasmInitialized) {
62206 throw new Error("initializeWasm() must be awaited first!");
62208 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
62209 return nativeResponseValue;
62211 // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
62213 export function BumpTransactionEvent_clone(orig: bigint): bigint {
62214 if(!isWasmInitialized) {
62215 throw new Error("initializeWasm() must be awaited first!");
62217 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
62218 return nativeResponseValue;
62220 // struct LDKBumpTransactionEvent BumpTransactionEvent_channel_close(struct LDKChannelId channel_id, struct LDKPublicKey counterparty_node_id, struct LDKThirtyTwoBytes claim_id, uint32_t package_target_feerate_sat_per_1000_weight, struct LDKTransaction commitment_tx, uint64_t commitment_tx_fee_satoshis, struct LDKAnchorDescriptor anchor_descriptor, struct LDKCVec_HTLCOutputInCommitmentZ pending_htlcs);
62222 export function BumpTransactionEvent_channel_close(channel_id: bigint, counterparty_node_id: number, claim_id: number, package_target_feerate_sat_per_1000_weight: number, commitment_tx: number, commitment_tx_fee_satoshis: bigint, anchor_descriptor: bigint, pending_htlcs: number): bigint {
62223 if(!isWasmInitialized) {
62224 throw new Error("initializeWasm() must be awaited first!");
62226 const nativeResponseValue = wasm.TS_BumpTransactionEvent_channel_close(channel_id, counterparty_node_id, claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, commitment_tx_fee_satoshis, anchor_descriptor, pending_htlcs);
62227 return nativeResponseValue;
62229 // struct LDKBumpTransactionEvent BumpTransactionEvent_htlcresolution(struct LDKChannelId channel_id, struct LDKPublicKey counterparty_node_id, struct LDKThirtyTwoBytes claim_id, uint32_t target_feerate_sat_per_1000_weight, struct LDKCVec_HTLCDescriptorZ htlc_descriptors, uint32_t tx_lock_time);
62231 export function BumpTransactionEvent_htlcresolution(channel_id: bigint, counterparty_node_id: number, claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
62232 if(!isWasmInitialized) {
62233 throw new Error("initializeWasm() must be awaited first!");
62235 const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(channel_id, counterparty_node_id, claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
62236 return nativeResponseValue;
62238 // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
62240 export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
62241 if(!isWasmInitialized) {
62242 throw new Error("initializeWasm() must be awaited first!");
62244 const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
62245 return nativeResponseValue;
62247 // void Input_free(struct LDKInput this_obj);
62249 export function Input_free(this_obj: bigint): void {
62250 if(!isWasmInitialized) {
62251 throw new Error("initializeWasm() must be awaited first!");
62253 const nativeResponseValue = wasm.TS_Input_free(this_obj);
62254 // debug statements here
62256 // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
62258 export function Input_get_outpoint(this_ptr: bigint): bigint {
62259 if(!isWasmInitialized) {
62260 throw new Error("initializeWasm() must be awaited first!");
62262 const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
62263 return nativeResponseValue;
62265 // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
62267 export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
62268 if(!isWasmInitialized) {
62269 throw new Error("initializeWasm() must be awaited first!");
62271 const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
62272 // debug statements here
62274 // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
62276 export function Input_get_previous_utxo(this_ptr: bigint): bigint {
62277 if(!isWasmInitialized) {
62278 throw new Error("initializeWasm() must be awaited first!");
62280 const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
62281 return nativeResponseValue;
62283 // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
62285 export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
62286 if(!isWasmInitialized) {
62287 throw new Error("initializeWasm() must be awaited first!");
62289 const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
62290 // debug statements here
62292 // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
62294 export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
62295 if(!isWasmInitialized) {
62296 throw new Error("initializeWasm() must be awaited first!");
62298 const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
62299 return nativeResponseValue;
62301 // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
62303 export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
62304 if(!isWasmInitialized) {
62305 throw new Error("initializeWasm() must be awaited first!");
62307 const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
62308 // debug statements here
62310 // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
62312 export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
62313 if(!isWasmInitialized) {
62314 throw new Error("initializeWasm() must be awaited first!");
62316 const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
62317 return nativeResponseValue;
62319 // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
62321 export function Input_clone_ptr(arg: bigint): bigint {
62322 if(!isWasmInitialized) {
62323 throw new Error("initializeWasm() must be awaited first!");
62325 const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
62326 return nativeResponseValue;
62328 // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
62330 export function Input_clone(orig: bigint): bigint {
62331 if(!isWasmInitialized) {
62332 throw new Error("initializeWasm() must be awaited first!");
62334 const nativeResponseValue = wasm.TS_Input_clone(orig);
62335 return nativeResponseValue;
62337 // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
62339 export function Input_hash(o: bigint): bigint {
62340 if(!isWasmInitialized) {
62341 throw new Error("initializeWasm() must be awaited first!");
62343 const nativeResponseValue = wasm.TS_Input_hash(o);
62344 return nativeResponseValue;
62346 // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
62348 export function Input_eq(a: bigint, b: bigint): boolean {
62349 if(!isWasmInitialized) {
62350 throw new Error("initializeWasm() must be awaited first!");
62352 const nativeResponseValue = wasm.TS_Input_eq(a, b);
62353 return nativeResponseValue;
62355 // void Utxo_free(struct LDKUtxo this_obj);
62357 export function Utxo_free(this_obj: bigint): void {
62358 if(!isWasmInitialized) {
62359 throw new Error("initializeWasm() must be awaited first!");
62361 const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
62362 // debug statements here
62364 // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
62366 export function Utxo_get_outpoint(this_ptr: bigint): bigint {
62367 if(!isWasmInitialized) {
62368 throw new Error("initializeWasm() must be awaited first!");
62370 const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
62371 return nativeResponseValue;
62373 // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
62375 export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
62376 if(!isWasmInitialized) {
62377 throw new Error("initializeWasm() must be awaited first!");
62379 const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
62380 // debug statements here
62382 // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
62384 export function Utxo_get_output(this_ptr: bigint): bigint {
62385 if(!isWasmInitialized) {
62386 throw new Error("initializeWasm() must be awaited first!");
62388 const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
62389 return nativeResponseValue;
62391 // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
62393 export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
62394 if(!isWasmInitialized) {
62395 throw new Error("initializeWasm() must be awaited first!");
62397 const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
62398 // debug statements here
62400 // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
62402 export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
62403 if(!isWasmInitialized) {
62404 throw new Error("initializeWasm() must be awaited first!");
62406 const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
62407 return nativeResponseValue;
62409 // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
62411 export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
62412 if(!isWasmInitialized) {
62413 throw new Error("initializeWasm() must be awaited first!");
62415 const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
62416 // debug statements here
62418 // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
62420 export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
62421 if(!isWasmInitialized) {
62422 throw new Error("initializeWasm() must be awaited first!");
62424 const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
62425 return nativeResponseValue;
62427 // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
62429 export function Utxo_clone_ptr(arg: bigint): bigint {
62430 if(!isWasmInitialized) {
62431 throw new Error("initializeWasm() must be awaited first!");
62433 const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
62434 return nativeResponseValue;
62436 // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
62438 export function Utxo_clone(orig: bigint): bigint {
62439 if(!isWasmInitialized) {
62440 throw new Error("initializeWasm() must be awaited first!");
62442 const nativeResponseValue = wasm.TS_Utxo_clone(orig);
62443 return nativeResponseValue;
62445 // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
62447 export function Utxo_hash(o: bigint): bigint {
62448 if(!isWasmInitialized) {
62449 throw new Error("initializeWasm() must be awaited first!");
62451 const nativeResponseValue = wasm.TS_Utxo_hash(o);
62452 return nativeResponseValue;
62454 // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
62456 export function Utxo_eq(a: bigint, b: bigint): boolean {
62457 if(!isWasmInitialized) {
62458 throw new Error("initializeWasm() must be awaited first!");
62460 const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
62461 return nativeResponseValue;
62463 // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
62465 export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
62466 if(!isWasmInitialized) {
62467 throw new Error("initializeWasm() must be awaited first!");
62469 const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
62470 return nativeResponseValue;
62472 // void CoinSelection_free(struct LDKCoinSelection this_obj);
62474 export function CoinSelection_free(this_obj: bigint): void {
62475 if(!isWasmInitialized) {
62476 throw new Error("initializeWasm() must be awaited first!");
62478 const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
62479 // debug statements here
62481 // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
62483 export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
62484 if(!isWasmInitialized) {
62485 throw new Error("initializeWasm() must be awaited first!");
62487 const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
62488 return nativeResponseValue;
62490 // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
62492 export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
62493 if(!isWasmInitialized) {
62494 throw new Error("initializeWasm() must be awaited first!");
62496 const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
62497 // debug statements here
62499 // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
62501 export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
62502 if(!isWasmInitialized) {
62503 throw new Error("initializeWasm() must be awaited first!");
62505 const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
62506 return nativeResponseValue;
62508 // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
62510 export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
62511 if(!isWasmInitialized) {
62512 throw new Error("initializeWasm() must be awaited first!");
62514 const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
62515 // debug statements here
62517 // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
62519 export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
62520 if(!isWasmInitialized) {
62521 throw new Error("initializeWasm() must be awaited first!");
62523 const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
62524 return nativeResponseValue;
62526 // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
62528 export function CoinSelection_clone_ptr(arg: bigint): bigint {
62529 if(!isWasmInitialized) {
62530 throw new Error("initializeWasm() must be awaited first!");
62532 const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
62533 return nativeResponseValue;
62535 // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
62537 export function CoinSelection_clone(orig: bigint): bigint {
62538 if(!isWasmInitialized) {
62539 throw new Error("initializeWasm() must be awaited first!");
62541 const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
62542 return nativeResponseValue;
62544 // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
62546 export function CoinSelectionSource_free(this_ptr: bigint): void {
62547 if(!isWasmInitialized) {
62548 throw new Error("initializeWasm() must be awaited first!");
62550 const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
62551 // debug statements here
62553 // void WalletSource_free(struct LDKWalletSource this_ptr);
62555 export function WalletSource_free(this_ptr: bigint): void {
62556 if(!isWasmInitialized) {
62557 throw new Error("initializeWasm() must be awaited first!");
62559 const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
62560 // debug statements here
62562 // void Wallet_free(struct LDKWallet this_obj);
62564 export function Wallet_free(this_obj: bigint): void {
62565 if(!isWasmInitialized) {
62566 throw new Error("initializeWasm() must be awaited first!");
62568 const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
62569 // debug statements here
62571 // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
62573 export function Wallet_new(source: bigint, logger: bigint): bigint {
62574 if(!isWasmInitialized) {
62575 throw new Error("initializeWasm() must be awaited first!");
62577 const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
62578 return nativeResponseValue;
62580 // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
62582 export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
62583 if(!isWasmInitialized) {
62584 throw new Error("initializeWasm() must be awaited first!");
62586 const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
62587 return nativeResponseValue;
62589 // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
62591 export function BumpTransactionEventHandler_free(this_obj: bigint): void {
62592 if(!isWasmInitialized) {
62593 throw new Error("initializeWasm() must be awaited first!");
62595 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
62596 // debug statements here
62598 // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
62600 export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
62601 if(!isWasmInitialized) {
62602 throw new Error("initializeWasm() must be awaited first!");
62604 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
62605 return nativeResponseValue;
62607 // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
62609 export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
62610 if(!isWasmInitialized) {
62611 throw new Error("initializeWasm() must be awaited first!");
62613 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
62614 // debug statements here
62616 // void GossipSync_free(struct LDKGossipSync this_ptr);
62618 export function GossipSync_free(this_ptr: bigint): void {
62619 if(!isWasmInitialized) {
62620 throw new Error("initializeWasm() must be awaited first!");
62622 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
62623 // debug statements here
62625 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
62627 export function GossipSync_p2_p(a: bigint): bigint {
62628 if(!isWasmInitialized) {
62629 throw new Error("initializeWasm() must be awaited first!");
62631 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
62632 return nativeResponseValue;
62634 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
62636 export function GossipSync_rapid(a: bigint): bigint {
62637 if(!isWasmInitialized) {
62638 throw new Error("initializeWasm() must be awaited first!");
62640 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
62641 return nativeResponseValue;
62643 // struct LDKGossipSync GossipSync_none(void);
62645 export function GossipSync_none(): bigint {
62646 if(!isWasmInitialized) {
62647 throw new Error("initializeWasm() must be awaited first!");
62649 const nativeResponseValue = wasm.TS_GossipSync_none();
62650 return nativeResponseValue;
62652 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
62654 export function GraphSyncError_free(this_ptr: bigint): void {
62655 if(!isWasmInitialized) {
62656 throw new Error("initializeWasm() must be awaited first!");
62658 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
62659 // debug statements here
62661 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
62663 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
62664 if(!isWasmInitialized) {
62665 throw new Error("initializeWasm() must be awaited first!");
62667 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
62668 return nativeResponseValue;
62670 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
62672 export function GraphSyncError_clone(orig: bigint): bigint {
62673 if(!isWasmInitialized) {
62674 throw new Error("initializeWasm() must be awaited first!");
62676 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
62677 return nativeResponseValue;
62679 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
62681 export function GraphSyncError_decode_error(a: bigint): bigint {
62682 if(!isWasmInitialized) {
62683 throw new Error("initializeWasm() must be awaited first!");
62685 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
62686 return nativeResponseValue;
62688 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
62690 export function GraphSyncError_lightning_error(a: bigint): bigint {
62691 if(!isWasmInitialized) {
62692 throw new Error("initializeWasm() must be awaited first!");
62694 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
62695 return nativeResponseValue;
62697 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
62699 export function RapidGossipSync_free(this_obj: bigint): void {
62700 if(!isWasmInitialized) {
62701 throw new Error("initializeWasm() must be awaited first!");
62703 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
62704 // debug statements here
62706 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
62708 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
62709 if(!isWasmInitialized) {
62710 throw new Error("initializeWasm() must be awaited first!");
62712 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
62713 return nativeResponseValue;
62715 // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph_no_std(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data, struct LDKCOption_u64Z current_time_unix);
62717 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
62718 if(!isWasmInitialized) {
62719 throw new Error("initializeWasm() must be awaited first!");
62721 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
62722 return nativeResponseValue;
62724 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
62726 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
62727 if(!isWasmInitialized) {
62728 throw new Error("initializeWasm() must be awaited first!");
62730 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
62731 return nativeResponseValue;
62733 // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
62735 export function Bolt11ParseError_free(this_ptr: bigint): void {
62736 if(!isWasmInitialized) {
62737 throw new Error("initializeWasm() must be awaited first!");
62739 const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
62740 // debug statements here
62742 // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
62744 export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
62745 if(!isWasmInitialized) {
62746 throw new Error("initializeWasm() must be awaited first!");
62748 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
62749 return nativeResponseValue;
62751 // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
62753 export function Bolt11ParseError_clone(orig: bigint): bigint {
62754 if(!isWasmInitialized) {
62755 throw new Error("initializeWasm() must be awaited first!");
62757 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
62758 return nativeResponseValue;
62760 // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
62762 export function Bolt11ParseError_bech32_error(a: bigint): bigint {
62763 if(!isWasmInitialized) {
62764 throw new Error("initializeWasm() must be awaited first!");
62766 const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
62767 return nativeResponseValue;
62769 // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
62771 export function Bolt11ParseError_parse_amount_error(a: number): bigint {
62772 if(!isWasmInitialized) {
62773 throw new Error("initializeWasm() must be awaited first!");
62775 const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
62776 return nativeResponseValue;
62778 // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
62780 export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
62781 if(!isWasmInitialized) {
62782 throw new Error("initializeWasm() must be awaited first!");
62784 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
62785 return nativeResponseValue;
62787 // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
62789 export function Bolt11ParseError_bad_prefix(): bigint {
62790 if(!isWasmInitialized) {
62791 throw new Error("initializeWasm() must be awaited first!");
62793 const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
62794 return nativeResponseValue;
62796 // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
62798 export function Bolt11ParseError_unknown_currency(): bigint {
62799 if(!isWasmInitialized) {
62800 throw new Error("initializeWasm() must be awaited first!");
62802 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
62803 return nativeResponseValue;
62805 // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
62807 export function Bolt11ParseError_unknown_si_prefix(): bigint {
62808 if(!isWasmInitialized) {
62809 throw new Error("initializeWasm() must be awaited first!");
62811 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
62812 return nativeResponseValue;
62814 // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
62816 export function Bolt11ParseError_malformed_hrp(): bigint {
62817 if(!isWasmInitialized) {
62818 throw new Error("initializeWasm() must be awaited first!");
62820 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
62821 return nativeResponseValue;
62823 // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
62825 export function Bolt11ParseError_too_short_data_part(): bigint {
62826 if(!isWasmInitialized) {
62827 throw new Error("initializeWasm() must be awaited first!");
62829 const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
62830 return nativeResponseValue;
62832 // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
62834 export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
62835 if(!isWasmInitialized) {
62836 throw new Error("initializeWasm() must be awaited first!");
62838 const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
62839 return nativeResponseValue;
62841 // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
62843 export function Bolt11ParseError_description_decode_error(a: number): bigint {
62844 if(!isWasmInitialized) {
62845 throw new Error("initializeWasm() must be awaited first!");
62847 const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
62848 return nativeResponseValue;
62850 // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
62852 export function Bolt11ParseError_padding_error(): bigint {
62853 if(!isWasmInitialized) {
62854 throw new Error("initializeWasm() must be awaited first!");
62856 const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
62857 return nativeResponseValue;
62859 // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
62861 export function Bolt11ParseError_integer_overflow_error(): bigint {
62862 if(!isWasmInitialized) {
62863 throw new Error("initializeWasm() must be awaited first!");
62865 const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
62866 return nativeResponseValue;
62868 // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
62870 export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
62871 if(!isWasmInitialized) {
62872 throw new Error("initializeWasm() must be awaited first!");
62874 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
62875 return nativeResponseValue;
62877 // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
62879 export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
62880 if(!isWasmInitialized) {
62881 throw new Error("initializeWasm() must be awaited first!");
62883 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
62884 return nativeResponseValue;
62886 // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
62888 export function Bolt11ParseError_invalid_script_hash_length(): bigint {
62889 if(!isWasmInitialized) {
62890 throw new Error("initializeWasm() must be awaited first!");
62892 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
62893 return nativeResponseValue;
62895 // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
62897 export function Bolt11ParseError_invalid_recovery_id(): bigint {
62898 if(!isWasmInitialized) {
62899 throw new Error("initializeWasm() must be awaited first!");
62901 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
62902 return nativeResponseValue;
62904 // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
62906 export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
62907 if(!isWasmInitialized) {
62908 throw new Error("initializeWasm() must be awaited first!");
62910 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
62911 return nativeResponseValue;
62913 // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
62915 export function Bolt11ParseError_skip(): bigint {
62916 if(!isWasmInitialized) {
62917 throw new Error("initializeWasm() must be awaited first!");
62919 const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
62920 return nativeResponseValue;
62922 // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
62924 export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
62925 if(!isWasmInitialized) {
62926 throw new Error("initializeWasm() must be awaited first!");
62928 const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
62929 return nativeResponseValue;
62931 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
62933 export function ParseOrSemanticError_free(this_ptr: bigint): void {
62934 if(!isWasmInitialized) {
62935 throw new Error("initializeWasm() must be awaited first!");
62937 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
62938 // debug statements here
62940 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
62942 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
62943 if(!isWasmInitialized) {
62944 throw new Error("initializeWasm() must be awaited first!");
62946 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
62947 return nativeResponseValue;
62949 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
62951 export function ParseOrSemanticError_clone(orig: bigint): bigint {
62952 if(!isWasmInitialized) {
62953 throw new Error("initializeWasm() must be awaited first!");
62955 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
62956 return nativeResponseValue;
62958 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
62960 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
62961 if(!isWasmInitialized) {
62962 throw new Error("initializeWasm() must be awaited first!");
62964 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
62965 return nativeResponseValue;
62967 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
62969 export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
62970 if(!isWasmInitialized) {
62971 throw new Error("initializeWasm() must be awaited first!");
62973 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
62974 return nativeResponseValue;
62976 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
62978 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
62979 if(!isWasmInitialized) {
62980 throw new Error("initializeWasm() must be awaited first!");
62982 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
62983 return nativeResponseValue;
62985 // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
62987 export function Bolt11Invoice_free(this_obj: bigint): void {
62988 if(!isWasmInitialized) {
62989 throw new Error("initializeWasm() must be awaited first!");
62991 const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
62992 // debug statements here
62994 // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
62996 export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
62997 if(!isWasmInitialized) {
62998 throw new Error("initializeWasm() must be awaited first!");
63000 const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
63001 return nativeResponseValue;
63003 // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
63005 export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
63006 if(!isWasmInitialized) {
63007 throw new Error("initializeWasm() must be awaited first!");
63009 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
63010 return nativeResponseValue;
63012 // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
63014 export function Bolt11Invoice_clone(orig: bigint): bigint {
63015 if(!isWasmInitialized) {
63016 throw new Error("initializeWasm() must be awaited first!");
63018 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
63019 return nativeResponseValue;
63021 // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
63023 export function Bolt11Invoice_hash(o: bigint): bigint {
63024 if(!isWasmInitialized) {
63025 throw new Error("initializeWasm() must be awaited first!");
63027 const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
63028 return nativeResponseValue;
63030 // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
63032 export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
63033 if(!isWasmInitialized) {
63034 throw new Error("initializeWasm() must be awaited first!");
63036 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
63037 // debug statements here
63039 // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
63041 export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
63042 if(!isWasmInitialized) {
63043 throw new Error("initializeWasm() must be awaited first!");
63045 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
63046 return nativeResponseValue;
63048 // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
63050 export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
63051 if(!isWasmInitialized) {
63052 throw new Error("initializeWasm() must be awaited first!");
63054 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
63055 return nativeResponseValue;
63057 // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
63059 export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
63060 if(!isWasmInitialized) {
63061 throw new Error("initializeWasm() must be awaited first!");
63063 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
63064 return nativeResponseValue;
63066 // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
63068 export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
63069 if(!isWasmInitialized) {
63070 throw new Error("initializeWasm() must be awaited first!");
63072 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
63073 return nativeResponseValue;
63075 // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
63077 export function RawBolt11Invoice_free(this_obj: bigint): void {
63078 if(!isWasmInitialized) {
63079 throw new Error("initializeWasm() must be awaited first!");
63081 const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
63082 // debug statements here
63084 // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
63086 export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
63087 if(!isWasmInitialized) {
63088 throw new Error("initializeWasm() must be awaited first!");
63090 const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
63091 return nativeResponseValue;
63093 // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
63095 export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
63096 if(!isWasmInitialized) {
63097 throw new Error("initializeWasm() must be awaited first!");
63099 const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
63100 // debug statements here
63102 // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
63104 export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
63105 if(!isWasmInitialized) {
63106 throw new Error("initializeWasm() must be awaited first!");
63108 const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
63109 return nativeResponseValue;
63111 // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
63113 export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
63114 if(!isWasmInitialized) {
63115 throw new Error("initializeWasm() must be awaited first!");
63117 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
63118 return nativeResponseValue;
63120 // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
63122 export function RawBolt11Invoice_clone(orig: bigint): bigint {
63123 if(!isWasmInitialized) {
63124 throw new Error("initializeWasm() must be awaited first!");
63126 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
63127 return nativeResponseValue;
63129 // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
63131 export function RawBolt11Invoice_hash(o: bigint): bigint {
63132 if(!isWasmInitialized) {
63133 throw new Error("initializeWasm() must be awaited first!");
63135 const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
63136 return nativeResponseValue;
63138 // void RawDataPart_free(struct LDKRawDataPart this_obj);
63140 export function RawDataPart_free(this_obj: bigint): void {
63141 if(!isWasmInitialized) {
63142 throw new Error("initializeWasm() must be awaited first!");
63144 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
63145 // debug statements here
63147 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
63149 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
63150 if(!isWasmInitialized) {
63151 throw new Error("initializeWasm() must be awaited first!");
63153 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
63154 return nativeResponseValue;
63156 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
63158 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
63159 if(!isWasmInitialized) {
63160 throw new Error("initializeWasm() must be awaited first!");
63162 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
63163 // debug statements here
63165 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
63167 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
63168 if(!isWasmInitialized) {
63169 throw new Error("initializeWasm() must be awaited first!");
63171 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
63172 return nativeResponseValue;
63174 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
63176 export function RawDataPart_clone_ptr(arg: bigint): bigint {
63177 if(!isWasmInitialized) {
63178 throw new Error("initializeWasm() must be awaited first!");
63180 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
63181 return nativeResponseValue;
63183 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
63185 export function RawDataPart_clone(orig: bigint): bigint {
63186 if(!isWasmInitialized) {
63187 throw new Error("initializeWasm() must be awaited first!");
63189 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
63190 return nativeResponseValue;
63192 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
63194 export function RawDataPart_hash(o: bigint): bigint {
63195 if(!isWasmInitialized) {
63196 throw new Error("initializeWasm() must be awaited first!");
63198 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
63199 return nativeResponseValue;
63201 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
63203 export function PositiveTimestamp_free(this_obj: bigint): void {
63204 if(!isWasmInitialized) {
63205 throw new Error("initializeWasm() must be awaited first!");
63207 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
63208 // debug statements here
63210 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
63212 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
63213 if(!isWasmInitialized) {
63214 throw new Error("initializeWasm() must be awaited first!");
63216 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
63217 return nativeResponseValue;
63219 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
63221 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
63222 if(!isWasmInitialized) {
63223 throw new Error("initializeWasm() must be awaited first!");
63225 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
63226 return nativeResponseValue;
63228 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
63230 export function PositiveTimestamp_clone(orig: bigint): bigint {
63231 if(!isWasmInitialized) {
63232 throw new Error("initializeWasm() must be awaited first!");
63234 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
63235 return nativeResponseValue;
63237 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
63239 export function PositiveTimestamp_hash(o: bigint): bigint {
63240 if(!isWasmInitialized) {
63241 throw new Error("initializeWasm() must be awaited first!");
63243 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
63244 return nativeResponseValue;
63246 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
63248 export function SiPrefix_clone(orig: bigint): SiPrefix {
63249 if(!isWasmInitialized) {
63250 throw new Error("initializeWasm() must be awaited first!");
63252 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
63253 return nativeResponseValue;
63255 // enum LDKSiPrefix SiPrefix_milli(void);
63257 export function SiPrefix_milli(): SiPrefix {
63258 if(!isWasmInitialized) {
63259 throw new Error("initializeWasm() must be awaited first!");
63261 const nativeResponseValue = wasm.TS_SiPrefix_milli();
63262 return nativeResponseValue;
63264 // enum LDKSiPrefix SiPrefix_micro(void);
63266 export function SiPrefix_micro(): SiPrefix {
63267 if(!isWasmInitialized) {
63268 throw new Error("initializeWasm() must be awaited first!");
63270 const nativeResponseValue = wasm.TS_SiPrefix_micro();
63271 return nativeResponseValue;
63273 // enum LDKSiPrefix SiPrefix_nano(void);
63275 export function SiPrefix_nano(): SiPrefix {
63276 if(!isWasmInitialized) {
63277 throw new Error("initializeWasm() must be awaited first!");
63279 const nativeResponseValue = wasm.TS_SiPrefix_nano();
63280 return nativeResponseValue;
63282 // enum LDKSiPrefix SiPrefix_pico(void);
63284 export function SiPrefix_pico(): SiPrefix {
63285 if(!isWasmInitialized) {
63286 throw new Error("initializeWasm() must be awaited first!");
63288 const nativeResponseValue = wasm.TS_SiPrefix_pico();
63289 return nativeResponseValue;
63291 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
63293 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
63294 if(!isWasmInitialized) {
63295 throw new Error("initializeWasm() must be awaited first!");
63297 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
63298 return nativeResponseValue;
63300 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
63302 export function SiPrefix_hash(o: bigint): bigint {
63303 if(!isWasmInitialized) {
63304 throw new Error("initializeWasm() must be awaited first!");
63306 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
63307 return nativeResponseValue;
63309 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
63311 export function SiPrefix_multiplier(this_arg: bigint): bigint {
63312 if(!isWasmInitialized) {
63313 throw new Error("initializeWasm() must be awaited first!");
63315 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
63316 return nativeResponseValue;
63318 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
63320 export function Currency_clone(orig: bigint): Currency {
63321 if(!isWasmInitialized) {
63322 throw new Error("initializeWasm() must be awaited first!");
63324 const nativeResponseValue = wasm.TS_Currency_clone(orig);
63325 return nativeResponseValue;
63327 // enum LDKCurrency Currency_bitcoin(void);
63329 export function Currency_bitcoin(): Currency {
63330 if(!isWasmInitialized) {
63331 throw new Error("initializeWasm() must be awaited first!");
63333 const nativeResponseValue = wasm.TS_Currency_bitcoin();
63334 return nativeResponseValue;
63336 // enum LDKCurrency Currency_bitcoin_testnet(void);
63338 export function Currency_bitcoin_testnet(): Currency {
63339 if(!isWasmInitialized) {
63340 throw new Error("initializeWasm() must be awaited first!");
63342 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
63343 return nativeResponseValue;
63345 // enum LDKCurrency Currency_regtest(void);
63347 export function Currency_regtest(): Currency {
63348 if(!isWasmInitialized) {
63349 throw new Error("initializeWasm() must be awaited first!");
63351 const nativeResponseValue = wasm.TS_Currency_regtest();
63352 return nativeResponseValue;
63354 // enum LDKCurrency Currency_simnet(void);
63356 export function Currency_simnet(): Currency {
63357 if(!isWasmInitialized) {
63358 throw new Error("initializeWasm() must be awaited first!");
63360 const nativeResponseValue = wasm.TS_Currency_simnet();
63361 return nativeResponseValue;
63363 // enum LDKCurrency Currency_signet(void);
63365 export function Currency_signet(): Currency {
63366 if(!isWasmInitialized) {
63367 throw new Error("initializeWasm() must be awaited first!");
63369 const nativeResponseValue = wasm.TS_Currency_signet();
63370 return nativeResponseValue;
63372 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
63374 export function Currency_hash(o: bigint): bigint {
63375 if(!isWasmInitialized) {
63376 throw new Error("initializeWasm() must be awaited first!");
63378 const nativeResponseValue = wasm.TS_Currency_hash(o);
63379 return nativeResponseValue;
63381 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
63383 export function Currency_eq(a: bigint, b: bigint): boolean {
63384 if(!isWasmInitialized) {
63385 throw new Error("initializeWasm() must be awaited first!");
63387 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
63388 return nativeResponseValue;
63390 // void Sha256_free(struct LDKSha256 this_obj);
63392 export function Sha256_free(this_obj: bigint): void {
63393 if(!isWasmInitialized) {
63394 throw new Error("initializeWasm() must be awaited first!");
63396 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
63397 // debug statements here
63399 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
63401 export function Sha256_clone_ptr(arg: bigint): bigint {
63402 if(!isWasmInitialized) {
63403 throw new Error("initializeWasm() must be awaited first!");
63405 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
63406 return nativeResponseValue;
63408 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
63410 export function Sha256_clone(orig: bigint): bigint {
63411 if(!isWasmInitialized) {
63412 throw new Error("initializeWasm() must be awaited first!");
63414 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
63415 return nativeResponseValue;
63417 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
63419 export function Sha256_hash(o: bigint): bigint {
63420 if(!isWasmInitialized) {
63421 throw new Error("initializeWasm() must be awaited first!");
63423 const nativeResponseValue = wasm.TS_Sha256_hash(o);
63424 return nativeResponseValue;
63426 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
63428 export function Sha256_eq(a: bigint, b: bigint): boolean {
63429 if(!isWasmInitialized) {
63430 throw new Error("initializeWasm() must be awaited first!");
63432 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
63433 return nativeResponseValue;
63435 // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
63437 export function Sha256_from_bytes(bytes: number): bigint {
63438 if(!isWasmInitialized) {
63439 throw new Error("initializeWasm() must be awaited first!");
63441 const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
63442 return nativeResponseValue;
63444 // void Description_free(struct LDKDescription this_obj);
63446 export function Description_free(this_obj: bigint): void {
63447 if(!isWasmInitialized) {
63448 throw new Error("initializeWasm() must be awaited first!");
63450 const nativeResponseValue = wasm.TS_Description_free(this_obj);
63451 // debug statements here
63453 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
63455 export function Description_clone_ptr(arg: bigint): bigint {
63456 if(!isWasmInitialized) {
63457 throw new Error("initializeWasm() must be awaited first!");
63459 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
63460 return nativeResponseValue;
63462 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
63464 export function Description_clone(orig: bigint): bigint {
63465 if(!isWasmInitialized) {
63466 throw new Error("initializeWasm() must be awaited first!");
63468 const nativeResponseValue = wasm.TS_Description_clone(orig);
63469 return nativeResponseValue;
63471 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
63473 export function Description_hash(o: bigint): bigint {
63474 if(!isWasmInitialized) {
63475 throw new Error("initializeWasm() must be awaited first!");
63477 const nativeResponseValue = wasm.TS_Description_hash(o);
63478 return nativeResponseValue;
63480 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
63482 export function Description_eq(a: bigint, b: bigint): boolean {
63483 if(!isWasmInitialized) {
63484 throw new Error("initializeWasm() must be awaited first!");
63486 const nativeResponseValue = wasm.TS_Description_eq(a, b);
63487 return nativeResponseValue;
63489 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
63491 export function PayeePubKey_free(this_obj: bigint): void {
63492 if(!isWasmInitialized) {
63493 throw new Error("initializeWasm() must be awaited first!");
63495 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
63496 // debug statements here
63498 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
63500 export function PayeePubKey_get_a(this_ptr: bigint): number {
63501 if(!isWasmInitialized) {
63502 throw new Error("initializeWasm() must be awaited first!");
63504 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
63505 return nativeResponseValue;
63507 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
63509 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
63510 if(!isWasmInitialized) {
63511 throw new Error("initializeWasm() must be awaited first!");
63513 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
63514 // debug statements here
63516 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
63518 export function PayeePubKey_new(a_arg: number): bigint {
63519 if(!isWasmInitialized) {
63520 throw new Error("initializeWasm() must be awaited first!");
63522 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
63523 return nativeResponseValue;
63525 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
63527 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
63528 if(!isWasmInitialized) {
63529 throw new Error("initializeWasm() must be awaited first!");
63531 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
63532 return nativeResponseValue;
63534 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
63536 export function PayeePubKey_clone(orig: bigint): bigint {
63537 if(!isWasmInitialized) {
63538 throw new Error("initializeWasm() must be awaited first!");
63540 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
63541 return nativeResponseValue;
63543 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
63545 export function PayeePubKey_hash(o: bigint): bigint {
63546 if(!isWasmInitialized) {
63547 throw new Error("initializeWasm() must be awaited first!");
63549 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
63550 return nativeResponseValue;
63552 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
63554 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
63555 if(!isWasmInitialized) {
63556 throw new Error("initializeWasm() must be awaited first!");
63558 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
63559 return nativeResponseValue;
63561 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
63563 export function ExpiryTime_free(this_obj: bigint): void {
63564 if(!isWasmInitialized) {
63565 throw new Error("initializeWasm() must be awaited first!");
63567 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
63568 // debug statements here
63570 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
63572 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
63573 if(!isWasmInitialized) {
63574 throw new Error("initializeWasm() must be awaited first!");
63576 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
63577 return nativeResponseValue;
63579 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
63581 export function ExpiryTime_clone(orig: bigint): bigint {
63582 if(!isWasmInitialized) {
63583 throw new Error("initializeWasm() must be awaited first!");
63585 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
63586 return nativeResponseValue;
63588 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
63590 export function ExpiryTime_hash(o: bigint): bigint {
63591 if(!isWasmInitialized) {
63592 throw new Error("initializeWasm() must be awaited first!");
63594 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
63595 return nativeResponseValue;
63597 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
63599 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
63600 if(!isWasmInitialized) {
63601 throw new Error("initializeWasm() must be awaited first!");
63603 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
63604 return nativeResponseValue;
63606 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
63608 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
63609 if(!isWasmInitialized) {
63610 throw new Error("initializeWasm() must be awaited first!");
63612 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
63613 // debug statements here
63615 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
63617 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
63618 if(!isWasmInitialized) {
63619 throw new Error("initializeWasm() must be awaited first!");
63621 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
63622 return nativeResponseValue;
63624 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
63626 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
63627 if(!isWasmInitialized) {
63628 throw new Error("initializeWasm() must be awaited first!");
63630 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
63631 // debug statements here
63633 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
63635 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
63636 if(!isWasmInitialized) {
63637 throw new Error("initializeWasm() must be awaited first!");
63639 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
63640 return nativeResponseValue;
63642 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
63644 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
63645 if(!isWasmInitialized) {
63646 throw new Error("initializeWasm() must be awaited first!");
63648 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
63649 return nativeResponseValue;
63651 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
63653 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
63654 if(!isWasmInitialized) {
63655 throw new Error("initializeWasm() must be awaited first!");
63657 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
63658 return nativeResponseValue;
63660 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
63662 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
63663 if(!isWasmInitialized) {
63664 throw new Error("initializeWasm() must be awaited first!");
63666 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
63667 return nativeResponseValue;
63669 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
63671 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
63672 if(!isWasmInitialized) {
63673 throw new Error("initializeWasm() must be awaited first!");
63675 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
63676 return nativeResponseValue;
63678 // void Fallback_free(struct LDKFallback this_ptr);
63680 export function Fallback_free(this_ptr: bigint): void {
63681 if(!isWasmInitialized) {
63682 throw new Error("initializeWasm() must be awaited first!");
63684 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
63685 // debug statements here
63687 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
63689 export function Fallback_clone_ptr(arg: bigint): bigint {
63690 if(!isWasmInitialized) {
63691 throw new Error("initializeWasm() must be awaited first!");
63693 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
63694 return nativeResponseValue;
63696 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
63698 export function Fallback_clone(orig: bigint): bigint {
63699 if(!isWasmInitialized) {
63700 throw new Error("initializeWasm() must be awaited first!");
63702 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
63703 return nativeResponseValue;
63705 // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
63707 export function Fallback_seg_wit_program(version: number, program: number): bigint {
63708 if(!isWasmInitialized) {
63709 throw new Error("initializeWasm() must be awaited first!");
63711 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
63712 return nativeResponseValue;
63714 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
63716 export function Fallback_pub_key_hash(a: number): bigint {
63717 if(!isWasmInitialized) {
63718 throw new Error("initializeWasm() must be awaited first!");
63720 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
63721 return nativeResponseValue;
63723 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
63725 export function Fallback_script_hash(a: number): bigint {
63726 if(!isWasmInitialized) {
63727 throw new Error("initializeWasm() must be awaited first!");
63729 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
63730 return nativeResponseValue;
63732 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
63734 export function Fallback_hash(o: bigint): bigint {
63735 if(!isWasmInitialized) {
63736 throw new Error("initializeWasm() must be awaited first!");
63738 const nativeResponseValue = wasm.TS_Fallback_hash(o);
63739 return nativeResponseValue;
63741 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
63743 export function Fallback_eq(a: bigint, b: bigint): boolean {
63744 if(!isWasmInitialized) {
63745 throw new Error("initializeWasm() must be awaited first!");
63747 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
63748 return nativeResponseValue;
63750 // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
63752 export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
63753 if(!isWasmInitialized) {
63754 throw new Error("initializeWasm() must be awaited first!");
63756 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
63757 // debug statements here
63759 // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
63761 export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
63762 if(!isWasmInitialized) {
63763 throw new Error("initializeWasm() must be awaited first!");
63765 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
63766 return nativeResponseValue;
63768 // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
63770 export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
63771 if(!isWasmInitialized) {
63772 throw new Error("initializeWasm() must be awaited first!");
63774 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
63775 return nativeResponseValue;
63777 // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
63779 export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
63780 if(!isWasmInitialized) {
63781 throw new Error("initializeWasm() must be awaited first!");
63783 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
63784 return nativeResponseValue;
63786 // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
63788 export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
63789 if(!isWasmInitialized) {
63790 throw new Error("initializeWasm() must be awaited first!");
63792 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
63793 return nativeResponseValue;
63795 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
63797 export function PrivateRoute_free(this_obj: bigint): void {
63798 if(!isWasmInitialized) {
63799 throw new Error("initializeWasm() must be awaited first!");
63801 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
63802 // debug statements here
63804 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
63806 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
63807 if(!isWasmInitialized) {
63808 throw new Error("initializeWasm() must be awaited first!");
63810 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
63811 return nativeResponseValue;
63813 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
63815 export function PrivateRoute_clone(orig: bigint): bigint {
63816 if(!isWasmInitialized) {
63817 throw new Error("initializeWasm() must be awaited first!");
63819 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
63820 return nativeResponseValue;
63822 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
63824 export function PrivateRoute_hash(o: bigint): bigint {
63825 if(!isWasmInitialized) {
63826 throw new Error("initializeWasm() must be awaited first!");
63828 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
63829 return nativeResponseValue;
63831 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
63833 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
63834 if(!isWasmInitialized) {
63835 throw new Error("initializeWasm() must be awaited first!");
63837 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
63838 return nativeResponseValue;
63840 // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
63842 export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
63843 if(!isWasmInitialized) {
63844 throw new Error("initializeWasm() must be awaited first!");
63846 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
63847 return nativeResponseValue;
63849 // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
63851 export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
63852 if(!isWasmInitialized) {
63853 throw new Error("initializeWasm() must be awaited first!");
63855 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
63856 return nativeResponseValue;
63858 // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
63860 export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
63861 if(!isWasmInitialized) {
63862 throw new Error("initializeWasm() must be awaited first!");
63864 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
63865 return nativeResponseValue;
63867 // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
63869 export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
63870 if(!isWasmInitialized) {
63871 throw new Error("initializeWasm() must be awaited first!");
63873 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
63874 return nativeResponseValue;
63876 // MUST_USE_RES struct LDKCResult_PayeePubKeySecp256k1ErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
63878 export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
63879 if(!isWasmInitialized) {
63880 throw new Error("initializeWasm() must be awaited first!");
63882 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
63883 return nativeResponseValue;
63885 // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
63887 export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
63888 if(!isWasmInitialized) {
63889 throw new Error("initializeWasm() must be awaited first!");
63891 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
63892 return nativeResponseValue;
63894 // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63896 export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
63897 if(!isWasmInitialized) {
63898 throw new Error("initializeWasm() must be awaited first!");
63900 const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
63901 return nativeResponseValue;
63903 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63905 export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
63906 if(!isWasmInitialized) {
63907 throw new Error("initializeWasm() must be awaited first!");
63909 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
63910 return nativeResponseValue;
63912 // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63914 export function RawBolt11Invoice_description(this_arg: bigint): bigint {
63915 if(!isWasmInitialized) {
63916 throw new Error("initializeWasm() must be awaited first!");
63918 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
63919 return nativeResponseValue;
63921 // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63923 export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
63924 if(!isWasmInitialized) {
63925 throw new Error("initializeWasm() must be awaited first!");
63927 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
63928 return nativeResponseValue;
63930 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63932 export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
63933 if(!isWasmInitialized) {
63934 throw new Error("initializeWasm() must be awaited first!");
63936 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
63937 return nativeResponseValue;
63939 // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63941 export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
63942 if(!isWasmInitialized) {
63943 throw new Error("initializeWasm() must be awaited first!");
63945 const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
63946 return nativeResponseValue;
63948 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63950 export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
63951 if(!isWasmInitialized) {
63952 throw new Error("initializeWasm() must be awaited first!");
63954 const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
63955 return nativeResponseValue;
63957 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63959 export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
63960 if(!isWasmInitialized) {
63961 throw new Error("initializeWasm() must be awaited first!");
63963 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
63964 return nativeResponseValue;
63966 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63968 export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
63969 if(!isWasmInitialized) {
63970 throw new Error("initializeWasm() must be awaited first!");
63972 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
63973 return nativeResponseValue;
63975 // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63977 export function RawBolt11Invoice_features(this_arg: bigint): bigint {
63978 if(!isWasmInitialized) {
63979 throw new Error("initializeWasm() must be awaited first!");
63981 const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
63982 return nativeResponseValue;
63984 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63986 export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
63987 if(!isWasmInitialized) {
63988 throw new Error("initializeWasm() must be awaited first!");
63990 const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
63991 return nativeResponseValue;
63993 // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
63995 export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
63996 if(!isWasmInitialized) {
63997 throw new Error("initializeWasm() must be awaited first!");
63999 const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
64000 return nativeResponseValue;
64002 // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
64004 export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
64005 if(!isWasmInitialized) {
64006 throw new Error("initializeWasm() must be awaited first!");
64008 const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
64009 return nativeResponseValue;
64011 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
64013 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
64014 if(!isWasmInitialized) {
64015 throw new Error("initializeWasm() must be awaited first!");
64017 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
64018 return nativeResponseValue;
64020 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
64022 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
64023 if(!isWasmInitialized) {
64024 throw new Error("initializeWasm() must be awaited first!");
64026 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
64027 return nativeResponseValue;
64029 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
64031 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
64032 if(!isWasmInitialized) {
64033 throw new Error("initializeWasm() must be awaited first!");
64035 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
64036 return nativeResponseValue;
64038 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
64040 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
64041 if(!isWasmInitialized) {
64042 throw new Error("initializeWasm() must be awaited first!");
64044 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
64045 return nativeResponseValue;
64047 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64049 export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
64050 if(!isWasmInitialized) {
64051 throw new Error("initializeWasm() must be awaited first!");
64053 const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
64054 return nativeResponseValue;
64056 // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
64058 export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
64059 if(!isWasmInitialized) {
64060 throw new Error("initializeWasm() must be awaited first!");
64062 const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
64063 return nativeResponseValue;
64065 // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64067 export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
64068 if(!isWasmInitialized) {
64069 throw new Error("initializeWasm() must be awaited first!");
64071 const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
64072 return nativeResponseValue;
64074 // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
64076 export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
64077 if(!isWasmInitialized) {
64078 throw new Error("initializeWasm() must be awaited first!");
64080 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
64081 return nativeResponseValue;
64083 // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64085 export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
64086 if(!isWasmInitialized) {
64087 throw new Error("initializeWasm() must be awaited first!");
64089 const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
64090 return nativeResponseValue;
64092 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
64094 export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
64095 if(!isWasmInitialized) {
64096 throw new Error("initializeWasm() must be awaited first!");
64098 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
64099 return nativeResponseValue;
64101 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64103 export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
64104 if(!isWasmInitialized) {
64105 throw new Error("initializeWasm() must be awaited first!");
64107 const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
64108 return nativeResponseValue;
64110 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
64112 export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
64113 if(!isWasmInitialized) {
64114 throw new Error("initializeWasm() must be awaited first!");
64116 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
64117 return nativeResponseValue;
64119 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64121 export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
64122 if(!isWasmInitialized) {
64123 throw new Error("initializeWasm() must be awaited first!");
64125 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
64126 return nativeResponseValue;
64128 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64130 export function Bolt11Invoice_features(this_arg: bigint): bigint {
64131 if(!isWasmInitialized) {
64132 throw new Error("initializeWasm() must be awaited first!");
64134 const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
64135 return nativeResponseValue;
64137 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64139 export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
64140 if(!isWasmInitialized) {
64141 throw new Error("initializeWasm() must be awaited first!");
64143 const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
64144 return nativeResponseValue;
64146 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_get_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64148 export function Bolt11Invoice_get_payee_pub_key(this_arg: bigint): number {
64149 if(!isWasmInitialized) {
64150 throw new Error("initializeWasm() must be awaited first!");
64152 const nativeResponseValue = wasm.TS_Bolt11Invoice_get_payee_pub_key(this_arg);
64153 return nativeResponseValue;
64155 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64157 export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
64158 if(!isWasmInitialized) {
64159 throw new Error("initializeWasm() must be awaited first!");
64161 const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
64162 return nativeResponseValue;
64164 // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64166 export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
64167 if(!isWasmInitialized) {
64168 throw new Error("initializeWasm() must be awaited first!");
64170 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
64171 return nativeResponseValue;
64173 // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
64175 export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
64176 if(!isWasmInitialized) {
64177 throw new Error("initializeWasm() must be awaited first!");
64179 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
64180 return nativeResponseValue;
64182 // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
64184 export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
64185 if(!isWasmInitialized) {
64186 throw new Error("initializeWasm() must be awaited first!");
64188 const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
64189 return nativeResponseValue;
64191 // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64193 export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
64194 if(!isWasmInitialized) {
64195 throw new Error("initializeWasm() must be awaited first!");
64197 const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
64198 return nativeResponseValue;
64200 // MUST_USE_RES struct LDKCVec_StrZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64202 export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
64203 if(!isWasmInitialized) {
64204 throw new Error("initializeWasm() must be awaited first!");
64206 const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
64207 return nativeResponseValue;
64209 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64211 export function Bolt11Invoice_private_routes(this_arg: bigint): number {
64212 if(!isWasmInitialized) {
64213 throw new Error("initializeWasm() must be awaited first!");
64215 const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
64216 return nativeResponseValue;
64218 // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64220 export function Bolt11Invoice_route_hints(this_arg: bigint): number {
64221 if(!isWasmInitialized) {
64222 throw new Error("initializeWasm() must be awaited first!");
64224 const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
64225 return nativeResponseValue;
64227 // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64229 export function Bolt11Invoice_currency(this_arg: bigint): Currency {
64230 if(!isWasmInitialized) {
64231 throw new Error("initializeWasm() must be awaited first!");
64233 const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
64234 return nativeResponseValue;
64236 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
64238 export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
64239 if(!isWasmInitialized) {
64240 throw new Error("initializeWasm() must be awaited first!");
64242 const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
64243 return nativeResponseValue;
64245 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
64247 export function Description_new(description: number): bigint {
64248 if(!isWasmInitialized) {
64249 throw new Error("initializeWasm() must be awaited first!");
64251 const nativeResponseValue = wasm.TS_Description_new(description);
64252 return nativeResponseValue;
64254 // MUST_USE_RES struct LDKUntrustedString Description_into_inner(struct LDKDescription this_arg);
64256 export function Description_into_inner(this_arg: bigint): bigint {
64257 if(!isWasmInitialized) {
64258 throw new Error("initializeWasm() must be awaited first!");
64260 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
64261 return nativeResponseValue;
64263 // struct LDKStr Description_to_str(const struct LDKDescription *NONNULL_PTR o);
64265 export function Description_to_str(o: bigint): number {
64266 if(!isWasmInitialized) {
64267 throw new Error("initializeWasm() must be awaited first!");
64269 const nativeResponseValue = wasm.TS_Description_to_str(o);
64270 return nativeResponseValue;
64272 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
64274 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
64275 if(!isWasmInitialized) {
64276 throw new Error("initializeWasm() must be awaited first!");
64278 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
64279 return nativeResponseValue;
64281 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
64283 export function ExpiryTime_from_duration(duration: bigint): bigint {
64284 if(!isWasmInitialized) {
64285 throw new Error("initializeWasm() must be awaited first!");
64287 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
64288 return nativeResponseValue;
64290 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
64292 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
64293 if(!isWasmInitialized) {
64294 throw new Error("initializeWasm() must be awaited first!");
64296 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
64297 return nativeResponseValue;
64299 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
64301 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
64302 if(!isWasmInitialized) {
64303 throw new Error("initializeWasm() must be awaited first!");
64305 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
64306 return nativeResponseValue;
64308 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
64310 export function PrivateRoute_new(hops: bigint): bigint {
64311 if(!isWasmInitialized) {
64312 throw new Error("initializeWasm() must be awaited first!");
64314 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
64315 return nativeResponseValue;
64317 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
64319 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
64320 if(!isWasmInitialized) {
64321 throw new Error("initializeWasm() must be awaited first!");
64323 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
64324 return nativeResponseValue;
64326 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
64328 export function CreationError_clone(orig: bigint): CreationError {
64329 if(!isWasmInitialized) {
64330 throw new Error("initializeWasm() must be awaited first!");
64332 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
64333 return nativeResponseValue;
64335 // enum LDKCreationError CreationError_description_too_long(void);
64337 export function CreationError_description_too_long(): CreationError {
64338 if(!isWasmInitialized) {
64339 throw new Error("initializeWasm() must be awaited first!");
64341 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
64342 return nativeResponseValue;
64344 // enum LDKCreationError CreationError_route_too_long(void);
64346 export function CreationError_route_too_long(): CreationError {
64347 if(!isWasmInitialized) {
64348 throw new Error("initializeWasm() must be awaited first!");
64350 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
64351 return nativeResponseValue;
64353 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
64355 export function CreationError_timestamp_out_of_bounds(): CreationError {
64356 if(!isWasmInitialized) {
64357 throw new Error("initializeWasm() must be awaited first!");
64359 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
64360 return nativeResponseValue;
64362 // enum LDKCreationError CreationError_invalid_amount(void);
64364 export function CreationError_invalid_amount(): CreationError {
64365 if(!isWasmInitialized) {
64366 throw new Error("initializeWasm() must be awaited first!");
64368 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
64369 return nativeResponseValue;
64371 // enum LDKCreationError CreationError_missing_route_hints(void);
64373 export function CreationError_missing_route_hints(): CreationError {
64374 if(!isWasmInitialized) {
64375 throw new Error("initializeWasm() must be awaited first!");
64377 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
64378 return nativeResponseValue;
64380 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
64382 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
64383 if(!isWasmInitialized) {
64384 throw new Error("initializeWasm() must be awaited first!");
64386 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
64387 return nativeResponseValue;
64389 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
64391 export function CreationError_eq(a: bigint, b: bigint): boolean {
64392 if(!isWasmInitialized) {
64393 throw new Error("initializeWasm() must be awaited first!");
64395 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
64396 return nativeResponseValue;
64398 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
64400 export function CreationError_to_str(o: bigint): number {
64401 if(!isWasmInitialized) {
64402 throw new Error("initializeWasm() must be awaited first!");
64404 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
64405 return nativeResponseValue;
64407 // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
64409 export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
64410 if(!isWasmInitialized) {
64411 throw new Error("initializeWasm() must be awaited first!");
64413 const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
64414 return nativeResponseValue;
64416 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
64418 export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
64419 if(!isWasmInitialized) {
64420 throw new Error("initializeWasm() must be awaited first!");
64422 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
64423 return nativeResponseValue;
64425 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
64427 export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
64428 if(!isWasmInitialized) {
64429 throw new Error("initializeWasm() must be awaited first!");
64431 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
64432 return nativeResponseValue;
64434 // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
64436 export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
64437 if(!isWasmInitialized) {
64438 throw new Error("initializeWasm() must be awaited first!");
64440 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
64441 return nativeResponseValue;
64443 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
64445 export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
64446 if(!isWasmInitialized) {
64447 throw new Error("initializeWasm() must be awaited first!");
64449 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
64450 return nativeResponseValue;
64452 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
64454 export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
64455 if(!isWasmInitialized) {
64456 throw new Error("initializeWasm() must be awaited first!");
64458 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
64459 return nativeResponseValue;
64461 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
64463 export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
64464 if(!isWasmInitialized) {
64465 throw new Error("initializeWasm() must be awaited first!");
64467 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
64468 return nativeResponseValue;
64470 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
64472 export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
64473 if(!isWasmInitialized) {
64474 throw new Error("initializeWasm() must be awaited first!");
64476 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
64477 return nativeResponseValue;
64479 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
64481 export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
64482 if(!isWasmInitialized) {
64483 throw new Error("initializeWasm() must be awaited first!");
64485 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
64486 return nativeResponseValue;
64488 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
64490 export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
64491 if(!isWasmInitialized) {
64492 throw new Error("initializeWasm() must be awaited first!");
64494 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
64495 return nativeResponseValue;
64497 // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
64499 export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
64500 if(!isWasmInitialized) {
64501 throw new Error("initializeWasm() must be awaited first!");
64503 const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
64504 return nativeResponseValue;
64506 // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
64508 export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
64509 if(!isWasmInitialized) {
64510 throw new Error("initializeWasm() must be awaited first!");
64512 const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
64513 return nativeResponseValue;
64515 // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
64517 export function Bolt11SemanticError_to_str(o: bigint): number {
64518 if(!isWasmInitialized) {
64519 throw new Error("initializeWasm() must be awaited first!");
64521 const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
64522 return nativeResponseValue;
64524 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
64526 export function SignOrCreationError_free(this_ptr: bigint): void {
64527 if(!isWasmInitialized) {
64528 throw new Error("initializeWasm() must be awaited first!");
64530 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
64531 // debug statements here
64533 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
64535 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
64536 if(!isWasmInitialized) {
64537 throw new Error("initializeWasm() must be awaited first!");
64539 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
64540 return nativeResponseValue;
64542 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
64544 export function SignOrCreationError_clone(orig: bigint): bigint {
64545 if(!isWasmInitialized) {
64546 throw new Error("initializeWasm() must be awaited first!");
64548 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
64549 return nativeResponseValue;
64551 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
64553 export function SignOrCreationError_sign_error(): bigint {
64554 if(!isWasmInitialized) {
64555 throw new Error("initializeWasm() must be awaited first!");
64557 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
64558 return nativeResponseValue;
64560 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
64562 export function SignOrCreationError_creation_error(a: CreationError): bigint {
64563 if(!isWasmInitialized) {
64564 throw new Error("initializeWasm() must be awaited first!");
64566 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
64567 return nativeResponseValue;
64569 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
64571 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
64572 if(!isWasmInitialized) {
64573 throw new Error("initializeWasm() must be awaited first!");
64575 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
64576 return nativeResponseValue;
64578 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
64580 export function SignOrCreationError_to_str(o: bigint): number {
64581 if(!isWasmInitialized) {
64582 throw new Error("initializeWasm() must be awaited first!");
64584 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
64585 return nativeResponseValue;
64587 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ payment_parameters_from_zero_amount_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msat);
64589 export function payment_parameters_from_zero_amount_invoice(invoice: bigint, amount_msat: bigint): bigint {
64590 if(!isWasmInitialized) {
64591 throw new Error("initializeWasm() must be awaited first!");
64593 const nativeResponseValue = wasm.TS_payment_parameters_from_zero_amount_invoice(invoice, amount_msat);
64594 return nativeResponseValue;
64596 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ payment_parameters_from_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice);
64598 export function payment_parameters_from_invoice(invoice: bigint): bigint {
64599 if(!isWasmInitialized) {
64600 throw new Error("initializeWasm() must be awaited first!");
64602 const nativeResponseValue = wasm.TS_payment_parameters_from_invoice(invoice);
64603 return nativeResponseValue;
64605 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKStr description, uint32_t invoice_expiry_delta_secs, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
64607 export function create_phantom_invoice(amt_msat: bigint, payment_hash: bigint, description: number, invoice_expiry_delta_secs: number, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
64608 if(!isWasmInitialized) {
64609 throw new Error("initializeWasm() must be awaited first!");
64611 const nativeResponseValue = wasm.TS_create_phantom_invoice(amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
64612 return nativeResponseValue;
64614 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice_with_description_hash(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ payment_hash, uint32_t invoice_expiry_delta_secs, struct LDKSha256 description_hash, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
64616 export function create_phantom_invoice_with_description_hash(amt_msat: bigint, payment_hash: bigint, invoice_expiry_delta_secs: number, description_hash: bigint, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
64617 if(!isWasmInitialized) {
64618 throw new Error("initializeWasm() must be awaited first!");
64620 const nativeResponseValue = wasm.TS_create_phantom_invoice_with_description_hash(amt_msat, payment_hash, invoice_expiry_delta_secs, description_hash, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
64621 return nativeResponseValue;
64623 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
64625 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
64626 if(!isWasmInitialized) {
64627 throw new Error("initializeWasm() must be awaited first!");
64629 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
64630 return nativeResponseValue;
64632 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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 LDKCOption_u16Z min_final_cltv_expiry_delta);
64634 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
64635 if(!isWasmInitialized) {
64636 throw new Error("initializeWasm() must be awaited first!");
64638 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
64639 return nativeResponseValue;
64641 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, 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, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
64643 export function create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, payment_hash: number, min_final_cltv_expiry_delta: bigint): bigint {
64644 if(!isWasmInitialized) {
64645 throw new Error("initializeWasm() must be awaited first!");
64647 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, payment_hash, min_final_cltv_expiry_delta);
64648 return nativeResponseValue;
64650 // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
64652 export function SiPrefix_from_str(s: number): bigint {
64653 if(!isWasmInitialized) {
64654 throw new Error("initializeWasm() must be awaited first!");
64656 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
64657 return nativeResponseValue;
64659 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
64661 export function Bolt11Invoice_from_str(s: number): bigint {
64662 if(!isWasmInitialized) {
64663 throw new Error("initializeWasm() must be awaited first!");
64665 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
64666 return nativeResponseValue;
64668 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
64670 export function SignedRawBolt11Invoice_from_str(s: number): bigint {
64671 if(!isWasmInitialized) {
64672 throw new Error("initializeWasm() must be awaited first!");
64674 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
64675 return nativeResponseValue;
64677 // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
64679 export function Bolt11ParseError_to_str(o: bigint): number {
64680 if(!isWasmInitialized) {
64681 throw new Error("initializeWasm() must be awaited first!");
64683 const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
64684 return nativeResponseValue;
64686 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
64688 export function ParseOrSemanticError_to_str(o: bigint): number {
64689 if(!isWasmInitialized) {
64690 throw new Error("initializeWasm() must be awaited first!");
64692 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
64693 return nativeResponseValue;
64695 // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
64697 export function Bolt11Invoice_to_str(o: bigint): number {
64698 if(!isWasmInitialized) {
64699 throw new Error("initializeWasm() must be awaited first!");
64701 const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
64702 return nativeResponseValue;
64704 // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
64706 export function SignedRawBolt11Invoice_to_str(o: bigint): number {
64707 if(!isWasmInitialized) {
64708 throw new Error("initializeWasm() must be awaited first!");
64710 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
64711 return nativeResponseValue;
64713 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
64715 export function Currency_to_str(o: bigint): number {
64716 if(!isWasmInitialized) {
64717 throw new Error("initializeWasm() must be awaited first!");
64719 const nativeResponseValue = wasm.TS_Currency_to_str(o);
64720 return nativeResponseValue;
64722 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
64724 export function SiPrefix_to_str(o: bigint): number {
64725 if(!isWasmInitialized) {
64726 throw new Error("initializeWasm() must be awaited first!");
64728 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
64729 return nativeResponseValue;
64733 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) {
64734 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
64735 if (weak == null || weak == undefined) {
64736 console.error("Got function call on unknown/free'd JS object!");
64737 throw new Error("Got function call on unknown/free'd JS object!");
64739 const obj = weak.deref();
64740 if (obj == null || obj == undefined) {
64741 console.error("Got function call on GC'd JS object!");
64742 throw new Error("Got function call on GC'd JS object!");
64746 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
64747 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
64748 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
64749 case 3: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
64750 case 4: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
64751 case 5: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
64752 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
64753 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment"); break;
64754 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
64755 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
64756 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
64757 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
64758 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
64759 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
64760 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
64761 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64762 case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
64763 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
64764 case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
64765 case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
64766 case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
64767 case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
64768 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
64769 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
64770 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
64771 case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
64772 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
64773 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice_request"); break;
64774 case 28: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice"); break;
64775 case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
64776 case 30: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
64777 case 31: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
64778 case 32: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
64779 case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
64780 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
64781 case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
64782 case 36: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
64783 case 37: fn = Object.getOwnPropertyDescriptor(obj, "create_blinded_paths"); break;
64784 case 38: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
64785 case 39: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
64786 case 40: fn = Object.getOwnPropertyDescriptor(obj, "create_blinded_payment_paths"); break;
64787 case 41: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
64788 case 42: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
64789 case 43: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64790 case 44: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
64791 case 45: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64792 case 46: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
64793 case 47: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
64794 case 48: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
64795 case 49: fn = Object.getOwnPropertyDescriptor(obj, "get_change_destination_script"); break;
64796 case 50: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
64797 case 51: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64798 case 52: fn = Object.getOwnPropertyDescriptor(obj, "remove"); break;
64799 case 53: fn = Object.getOwnPropertyDescriptor(obj, "list"); break;
64800 case 54: fn = Object.getOwnPropertyDescriptor(obj, "spend_spendable_outputs"); break;
64801 case 55: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
64802 case 56: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
64803 case 57: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
64804 case 58: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
64805 case 59: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
64806 case 60: fn = Object.getOwnPropertyDescriptor(obj, "time_passed"); break;
64807 case 61: fn = Object.getOwnPropertyDescriptor(obj, "read_lock"); break;
64808 case 62: fn = Object.getOwnPropertyDescriptor(obj, "write_lock"); break;
64809 case 63: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64810 case 64: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
64811 case 65: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
64812 case 66: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
64813 case 67: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
64814 case 68: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
64815 case 69: fn = Object.getOwnPropertyDescriptor(obj, "archive_persisted_channel"); break;
64816 case 70: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
64817 case 71: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
64818 case 72: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
64819 case 73: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
64820 case 74: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
64821 case 75: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
64822 case 76: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
64823 case 77: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
64824 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
64825 case 79: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
64826 case 80: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
64827 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
64828 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
64829 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
64830 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
64831 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
64832 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
64833 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
64834 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
64835 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
64836 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_stfu"); break;
64837 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
64838 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
64839 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
64840 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
64841 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
64842 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
64843 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
64844 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
64845 case 99: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
64846 case 100: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
64847 case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
64848 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
64849 case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
64850 case 104: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
64851 case 105: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
64852 case 106: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
64853 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
64854 case 108: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
64855 case 109: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
64856 case 110: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
64857 case 111: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
64858 case 112: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
64859 case 113: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
64860 case 114: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
64861 case 115: fn = Object.getOwnPropertyDescriptor(obj, "get_chain_hashes"); break;
64862 case 116: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
64863 case 117: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_messages"); break;
64864 case 118: fn = Object.getOwnPropertyDescriptor(obj, "next_node_id"); break;
64865 case 119: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
64866 case 120: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
64867 case 121: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
64868 case 122: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
64869 case 123: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
64870 case 124: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
64871 case 125: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
64872 case 126: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
64873 case 127: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
64874 case 128: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
64875 case 129: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
64876 case 130: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
64877 case 131: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
64878 case 132: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_connections_needed"); break;
64879 case 133: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
64880 case 134: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
64881 case 135: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
64882 case 136: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
64883 case 137: fn = Object.getOwnPropertyDescriptor(obj, "timer_tick_occurred"); break;
64884 case 138: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
64885 case 139: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
64886 case 140: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
64887 case 141: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
64888 case 142: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
64889 case 143: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
64890 case 144: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
64891 case 145: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
64892 case 146: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
64893 case 147: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_custom_messages"); break;
64894 case 148: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
64895 case 149: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
64896 case 150: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
64897 case 151: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
64898 case 152: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
64899 case 153: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice_request"); break;
64900 case 154: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
64901 case 155: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
64902 case 156: fn = Object.getOwnPropertyDescriptor(obj, "sign_psbt"); break;
64903 case 157: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
64904 case 158: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
64905 case 159: fn = Object.getOwnPropertyDescriptor(obj, "sign_psbt"); break;
64907 console.error("Got unknown function call with id " + fn_id + " from C!");
64908 throw new Error("Got unknown function call with id " + fn_id + " from C!");
64910 if (fn == null || fn == undefined) {
64911 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
64912 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
64916 ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
64918 console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
64922 if (ret === undefined || ret === null) return BigInt(0);
64923 return BigInt(ret);